Hello community,
here is the log from the commit of package perl-Crypt-Rijndael for
openSUSE:Factory checked in at 2020-10-15 13:46:25
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/perl-Crypt-Rijndael (Old)
and /work/SRC/openSUSE:Factory/.perl-Crypt-Rijndael.new.3486 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-Crypt-Rijndael"
Thu Oct 15 13:46:25 2020 rev:16 rq:841445 version:1.15
Changes:
--------
--- /work/SRC/openSUSE:Factory/perl-Crypt-Rijndael/perl-Crypt-Rijndael.changes
2019-06-17 10:31:17.465329601 +0200
+++
/work/SRC/openSUSE:Factory/.perl-Crypt-Rijndael.new.3486/perl-Crypt-Rijndael.changes
2020-10-15 13:46:43.921207617 +0200
@@ -1,0 +2,9 @@
+Sun Oct 11 03:07:15 UTC 2020 - Tina Müller <[email protected]>
+
+- updated to 1.15
+ see /usr/share/doc/packages/perl-Crypt-Rijndael/Changes
+
+ 1.15 - 2020-10-10
+ * Use standard uint8_t and uint32_t from stdint.h
+
+-------------------------------------------------------------------
Old:
----
Crypt-Rijndael-1.14.tar.gz
New:
----
Crypt-Rijndael-1.15.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ perl-Crypt-Rijndael.spec ++++++
--- /var/tmp/diff_new_pack.K20xok/_old 2020-10-15 13:46:45.365208181 +0200
+++ /var/tmp/diff_new_pack.K20xok/_new 2020-10-15 13:46:45.369208183 +0200
@@ -1,7 +1,7 @@
#
# spec file for package perl-Crypt-Rijndael
#
-# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2020 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,14 +17,14 @@
Name: perl-Crypt-Rijndael
-Version: 1.14
+Version: 1.15
Release: 0
#Upstream: SUSE-Public-Domain
%define cpan_name Crypt-Rijndael
Summary: Crypt::CBC compliant Rijndael encryption module
License: LGPL-3.0-only
Group: Development/Libraries/Perl
-Url: https://metacpan.org/release/%{cpan_name}
+URL: https://metacpan.org/release/%{cpan_name}
Source0:
https://cpan.metacpan.org/authors/id/L/LE/LEONT/%{cpan_name}-%{version}.tar.gz
Source1: cpanspec.yml
BuildRoot: %{_tmppath}/%{name}-%{version}-build
++++++ Crypt-Rijndael-1.14.tar.gz -> Crypt-Rijndael-1.15.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/Changes
new/Crypt-Rijndael-1.15/Changes
--- old/Crypt-Rijndael-1.14/Changes 2019-06-14 19:58:33.000000000 +0200
+++ new/Crypt-Rijndael-1.15/Changes 2020-10-10 21:27:33.000000000 +0200
@@ -1,5 +1,8 @@
Revision history for Perl module Crypt::Rijndael
+1.15 - 2020-10-10
+ * Use standard uint8_t and uint32_t from stdint.h
+
1.14 - 2019-06-14
* Fix UINT32 and UINT8 for musl libc
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/META.json
new/Crypt-Rijndael-1.15/META.json
--- old/Crypt-Rijndael-1.14/META.json 2019-06-14 19:59:17.000000000 +0200
+++ new/Crypt-Rijndael-1.15/META.json 2020-10-10 21:30:20.000000000 +0200
@@ -6,13 +6,13 @@
"Leon Timmermans <[email protected]>"
],
"dynamic_config" : 0,
- "generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter
version 2.150005",
+ "generated_by" : "ExtUtils::MakeMaker version 7.44, CPAN::Meta::Converter
version 2.150010",
"license" : [
"open_source"
],
"meta-spec" : {
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";,
- "version" : "2"
+ "version" : 2
},
"name" : "Crypt-Rijndael",
"no_index" : {
@@ -55,6 +55,6 @@
"web" : "https://github.com/leont/crypt-rijndael";
}
},
- "version" : "1.14",
- "x_serialization_backend" : "JSON::PP version 2.27300"
+ "version" : "1.15",
+ "x_serialization_backend" : "JSON::PP version 4.04"
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/META.yml
new/Crypt-Rijndael-1.15/META.yml
--- old/Crypt-Rijndael-1.14/META.yml 2019-06-14 19:59:17.000000000 +0200
+++ new/Crypt-Rijndael-1.15/META.yml 2020-10-10 21:30:20.000000000 +0200
@@ -10,7 +10,7 @@
configure_requires:
ExtUtils::MakeMaker: '0'
dynamic_config: 0
-generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version
2.150005'
+generated_by: 'ExtUtils::MakeMaker version 7.44, CPAN::Meta::Converter version
2.150010'
license: open_source
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
@@ -26,5 +26,5 @@
bugtracker: https://github.com/leont/crypt-rijndael/issues
homepage: https://github.com/leont/crypt-rijndael
repository: https://github.com/leont/crypt-rijndael.git
-version: '1.14'
+version: '1.15'
x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/Rijndael.pm
new/Crypt-Rijndael-1.15/Rijndael.pm
--- old/Crypt-Rijndael-1.14/Rijndael.pm 2019-06-14 19:57:20.000000000 +0200
+++ new/Crypt-Rijndael-1.15/Rijndael.pm 2020-10-10 21:28:31.000000000 +0200
@@ -3,7 +3,7 @@
use strict;
use warnings;
-our $VERSION = '1.14';
+our $VERSION = '1.15';
use XSLoader;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/Rijndael.xs
new/Crypt-Rijndael-1.15/Rijndael.xs
--- old/Crypt-Rijndael-1.14/Rijndael.xs 2015-12-04 01:05:15.000000000 +0100
+++ new/Crypt-Rijndael-1.15/Rijndael.xs 2020-10-10 21:27:06.000000000 +0200
@@ -31,7 +31,7 @@
typedef struct cryptstate {
RIJNDAEL_context ctx;
- UINT8 iv[RIJNDAEL_BLOCKSIZE];
+ uint8_t iv[RIJNDAEL_BLOCKSIZE];
int mode;
} *Crypt__Rijndael;
@@ -76,7 +76,7 @@
RETVAL->ctx.mode = RETVAL->mode = mode;
/* set the IV to zero on initialization */
Zero(RETVAL->iv, RIJNDAEL_BLOCKSIZE, char);
- rijndael_setup(&RETVAL->ctx, keysize, (UINT8 *)
SvPV_nolen(key));
+ rijndael_setup(&RETVAL->ctx, keysize, (uint8_t *)
SvPV_nolen(key));
}
OUTPUT:
RETVAL
@@ -111,7 +111,7 @@
void *rawbytes = SvPV(data,size);
if (size) {
- UINT8* buffer;
+ uint8_t* buffer;
if (size % RIJNDAEL_BLOCKSIZE)
Perl_croak(aTHX_ "encrypt: datasize not
multiple of blocksize (%d bytes)", RIJNDAEL_BLOCKSIZE);
@@ -119,7 +119,7 @@
RETVAL = newSV(size);
SvPOK_only(RETVAL);
SvCUR_set(RETVAL, size);
- buffer = (UINT8 *)SvPV_nolen(RETVAL);
+ buffer = (uint8_t *)SvPV_nolen(RETVAL);
(ix ? block_decrypt : block_encrypt)
(&self->ctx, rawbytes, size, buffer, self->iv);
buffer[size] = '\0';
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/_rijndael.c
new/Crypt-Rijndael-1.15/_rijndael.c
--- old/Crypt-Rijndael-1.14/_rijndael.c 2015-12-04 01:05:15.000000000 +0100
+++ new/Crypt-Rijndael-1.15/_rijndael.c 2020-10-10 21:27:06.000000000 +0200
@@ -22,11 +22,12 @@
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
+#include <stdint.h>
#if 0
static void
-print_block(UINT8 *block)
+print_block(uint8_t *block)
{
int i;
@@ -40,7 +41,7 @@
that we can perform a round's encryption or by means of four table lookups
and four XOR's per column of state. They were generated by the
makertbls.pl script. */
-UINT32 dtbl[] = {
+uint32_t dtbl[] = {
0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6,
0x0df2f2ff, 0xbd6b6bd6, 0xb16f6fde, 0x54c5c591,
0x50303060, 0x03010102, 0xa96767ce, 0x7d2b2b56,
@@ -107,7 +108,7 @@
0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d, 0x3a16162c,
};
-UINT32 itbl[] = {
+uint32_t itbl[] = {
0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a,
0xcb6bab3b, 0xf1459d1f, 0xab58faac, 0x9303e34b,
0x55fa3020, 0xf66d76ad, 0x9176cc88, 0x254c02f5,
@@ -176,7 +177,7 @@
/* Needed only for the key schedule and for final rounds */
-UINT8 sbox[256] = {
+uint8_t sbox[256] = {
99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171,
118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164,
114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113,
@@ -197,7 +198,7 @@
22,
};
-UINT8 isbox[256] = {
+uint8_t isbox[256] = {
82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215,
251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222,
233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66,
@@ -219,7 +220,7 @@
};
/* Used only by the key schedule */
-UINT8 Logtable[256] = {
+uint8_t Logtable[256] = {
0, 0, 25, 1, 50, 2, 26, 198, 75, 199, 27, 104, 51, 238, 223, 3,
100, 4, 224, 14, 52, 141, 129, 239, 76, 113, 8, 200, 248, 105, 28,
193, 125, 194, 29, 181, 249, 185, 39, 106, 77, 228, 166, 114, 154, 201,
@@ -239,7 +240,7 @@
74, 237, 222, 197, 49, 254, 24, 13, 99, 140, 128, 192, 247, 112, 7,
};
-UINT8 Alogtable[256] = {
+uint8_t Alogtable[256] = {
1, 3, 5, 15, 17, 51, 85, 255, 26, 46, 114, 150, 161, 248, 19,
53, 95, 225, 56, 72, 216, 115, 149, 164, 247, 2, 6, 10, 30, 34,
102, 170, 229, 52, 92, 228, 55, 89, 235, 38, 106, 190, 217, 112, 144,
@@ -266,10 +267,10 @@
((box)[(((x) >> 16) & 0xff)] << 16) | \
((box)[(((x) >> 24) & 0xff)] << 24))
-static UINT8
-xtime(UINT8 a)
+static uint8_t
+xtime(uint8_t a)
{
- UINT8 b;
+ uint8_t b;
b = (a & 0x80) ? 0x1b : 0;
a<<=1;
@@ -277,17 +278,17 @@
return(a);
}
-static UINT8
-mul(UINT8 a, UINT8 b)
+static uint8_t
+mul(uint8_t a, uint8_t b)
{
if (a && b) return Alogtable[(Logtable[a] + Logtable[b])%255];
else return 0;
}
static void
-inv_mix_column(UINT32 *a, UINT32 *b)
+inv_mix_column(uint32_t *a, uint32_t *b)
{
- UINT8 c[4][4];
+ uint8_t c[4][4];
int i, j;
for(j = 0; j < 4; j++) {
@@ -306,10 +307,10 @@
}
void
-rijndael_setup(RIJNDAEL_context *ctx, size_t keysize, const UINT8 *key)
+rijndael_setup(RIJNDAEL_context *ctx, size_t keysize, const uint8_t *key)
{
int nk, nr, i, lastkey;
- UINT32 temp, rcon;
+ uint32_t temp, rcon;
/* Truncate keysizes to the valid key sizes provided by Rijndael */
if (keysize >= 32) {
@@ -335,7 +336,7 @@
temp = ctx->keys[i-1];
if (i % nk == 0) {
temp = SUBBYTE(ROTBYTE(temp), sbox) ^ rcon;
- rcon = (UINT32)xtime((UINT8)rcon&0xff);
+ rcon = (uint32_t)xtime((uint8_t)rcon&0xff);
} else if (nk > 6 && (i%nk) == 4) {
temp = SUBBYTE(temp, sbox);
}
@@ -352,11 +353,11 @@
/* Key addition that also packs every byte in the key to a word rep. */
static void
-key_addition_8to32(const UINT8 *txt, UINT32 *keys, UINT32 *out)
+key_addition_8to32(const uint8_t *txt, uint32_t *keys, uint32_t *out)
{
- const UINT8 *ptr;
+ const uint8_t *ptr;
int i, j;
- UINT32 val;
+ uint32_t val;
ptr = txt;
for (i=0; i<4; i++) {
@@ -368,7 +369,7 @@
}
static void
-key_addition32(const UINT32 *txt, UINT32 *keys, UINT32 *out)
+key_addition32(const uint32_t *txt, uint32_t *keys, uint32_t *out)
{
int i;
@@ -377,11 +378,11 @@
}
static void
-key_addition32to8(const UINT32 *txt, UINT32 *keys, UINT8 *out)
+key_addition32to8(const uint32_t *txt, uint32_t *keys, uint8_t *out)
{
- UINT8 *ptr;
+ uint8_t *ptr;
int i, j;
- UINT32 val;
+ uint32_t val;
ptr = out;
for (i=0; i<4; i++) {
@@ -399,12 +400,12 @@
void
rijndael_encrypt(RIJNDAEL_context *ctx,
- const UINT8 *plaintext,
- UINT8 *ciphertext)
+ const uint8_t *plaintext,
+ uint8_t *ciphertext)
{
int r, j;
- UINT32 wtxt[4], t[4]; /* working ciphertext */
- UINT32 e;
+ uint32_t wtxt[4], t[4]; /* working ciphertext */
+ uint32_t e;
key_addition_8to32(plaintext, &(ctx->keys[0]), wtxt);
for (r=1; r<ctx->nrounds; r++) {
@@ -438,12 +439,12 @@
void
rijndael_decrypt(RIJNDAEL_context *ctx,
- const UINT8 *ciphertext,
- UINT8 *plaintext)
+ const uint8_t *ciphertext,
+ uint8_t *plaintext)
{
int r, j;
- UINT32 wtxt[4], t[4]; /* working ciphertext */
- UINT32 e;
+ uint32_t wtxt[4], t[4]; /* working ciphertext */
+ uint32_t e;
key_addition_8to32(ciphertext, &(ctx->ikeys[4*ctx->nrounds]), wtxt);
for (r=ctx->nrounds-1; r> 0; r--) {
@@ -470,11 +471,11 @@
}
void
-block_encrypt(RIJNDAEL_context *ctx, UINT8 *input, int inputlen,
- UINT8 *output, UINT8 *iv)
+block_encrypt(RIJNDAEL_context *ctx, uint8_t *input, int inputlen,
+ uint8_t *output, uint8_t *iv)
{
int i, j, nblocks, carry_flg;
- UINT8 block[RIJNDAEL_BLOCKSIZE], block2[RIJNDAEL_BLOCKSIZE], oldptxt;
+ uint8_t block[RIJNDAEL_BLOCKSIZE], block2[RIJNDAEL_BLOCKSIZE], oldptxt;
nblocks = inputlen / RIJNDAEL_BLOCKSIZE;
@@ -539,11 +540,11 @@
}
void
-block_decrypt(RIJNDAEL_context *ctx, UINT8 *input, int inputlen,
- UINT8 *output, UINT8 *iv)
+block_decrypt(RIJNDAEL_context *ctx, uint8_t *input, int inputlen,
+ uint8_t *output, uint8_t *iv)
{
int i, j, nblocks, carry_flg;
- UINT8 block[RIJNDAEL_BLOCKSIZE], block2[RIJNDAEL_BLOCKSIZE];
+ uint8_t block[RIJNDAEL_BLOCKSIZE], block2[RIJNDAEL_BLOCKSIZE];
nblocks = inputlen / RIJNDAEL_BLOCKSIZE;
switch (ctx->mode) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/Crypt-Rijndael-1.14/rijndael.h
new/Crypt-Rijndael-1.15/rijndael.h
--- old/Crypt-Rijndael-1.14/rijndael.h 2019-06-14 19:56:29.000000000 +0200
+++ new/Crypt-Rijndael-1.15/rijndael.h 2020-10-10 21:27:06.000000000 +0200
@@ -27,89 +27,10 @@
#if !defined(RIJNDAEL_H)
#define RIJNDAEL_H
+#include <stdint.h>
#include <stdlib.h>
#include <sys/types.h>
-#ifdef _CRYPT_RIJNDAEL_H_TYPES
- #undef _CRYPT_RIJNDAEL_H_TYPES
-#endif
-
-/* Irix. We could include stdint.h and use uint8_t but that also
- * requires that we specifically drive the compiler in C99 mode.
- * Defining UINT8 as unsigned char is, ultimately, what stdint.h
- * would do anyway.
- */
-#if defined(_SGIAPI) || defined( __sgi )
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef __uint32_t UINT32;
- typedef unsigned char UINT8;
-#endif
-
-/* Solaris has sys/types.h, but doesn't act like everyone else
- * GCC defines __sun__ and __sun (report from Todd Ross)
- * Solaris cc defines __sun
- * MirBSD defines the same types as Solaris
- */
-#if defined( __sun__ ) || defined( __sun ) || defined( __MirBSD__ )
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef uint32_t UINT32;
- typedef uint8_t UINT8;
-#endif
-
-/* Mac OS X 10.3 defines things differently than most other
-systems */
-#if defined( __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ ) &&
__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__-0 < 1140
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef u_int32_t UINT32;
- typedef u_char UINT8;
-#endif
-
-/* Mac OS X 10.3 defines things differently than most other
-systems */
-#if defined(__APPLE__) && ! defined(__DARWIN_UNIX03)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef u_int32_t UINT32;
- typedef u_char UINT8;
-#endif
-
-/* Systems with musl libc have a sys/types.h with these definitions. */
-#if ! defined(_CRYPT_RIJNDAEL_H_TYPES) && defined(__DEFINED_uint32_t) &&
defined(__DEFINED_uint8_t)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef uint32_t UINT32;
- typedef uint8_t UINT8;
-#endif
-
-/* I expect this to be the usual case */
-#if ! defined(_CRYPT_RIJNDAEL_H_TYPES) && ( defined(_SYS_TYPES_H) ||
defined(_SYS_TYPES_H_) )
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef __uint32_t UINT32;
- typedef __uint8_t UINT8;
-#endif
-
-#if defined(__CYGWIN__) && ! defined(_CRYPT_RIJNDAEL_H_TYPES)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef unsigned int UINT32;
- typedef unsigned char UINT8;
-#endif
-
-#if defined(__MINGW32__) && ! defined(_CRYPT_RIJNDAEL_H_TYPES)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef unsigned int UINT32;
- typedef unsigned char UINT8;
-#endif
-
-#if defined(WIN32) && ! defined(_CRYPT_RIJNDAEL_H_TYPES)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef unsigned int UINT32;
- typedef unsigned char UINT8;
-#endif
-
-#if ! defined(_CRYPT_RIJNDAEL_H_TYPES)
- #define _CRYPT_RIJNDAEL_H_TYPES
- typedef unsigned int UINT32;
- typedef unsigned char UINT8;
-#endif
-
/* Other block sizes and key lengths are possible, but in the context of
* the ssh protocols, 256 bits is the default.
*/
@@ -129,8 +50,8 @@
#define RIJNDAEL_MAX_KEYSIZE 32
typedef struct {
- UINT32 keys[60]; /* maximum size of key schedule */
- UINT32 ikeys[60]; /* inverse key schedule */
+ uint32_t keys[60]; /* maximum size of key schedule */
+ uint32_t ikeys[60]; /* inverse key schedule */
int nrounds; /* number of rounds to use for our key size */
int mode; /* encryption mode */
} RIJNDAEL_context;
@@ -144,7 +65,7 @@
* PASS A VALUE LESS THAN 16 TO KEYSIZE!
*/
void
-rijndael_setup(RIJNDAEL_context *ctx, size_t keysize, const UINT8 *key);
+rijndael_setup(RIJNDAEL_context *ctx, size_t keysize, const uint8_t *key);
/*
* rijndael_encrypt()
@@ -160,8 +81,8 @@
void
rijndael_encrypt(RIJNDAEL_context *context,
- const UINT8 *plaintext,
- UINT8 *ciphertext);
+ const uint8_t *plaintext,
+ uint8_t *ciphertext);
/*
* rijndael_decrypt()
@@ -178,18 +99,18 @@
void
rijndael_decrypt(RIJNDAEL_context *context,
- const UINT8 *ciphertext,
- UINT8 *plaintext);
+ const uint8_t *ciphertext,
+ uint8_t *plaintext);
/* Encrypt a block of plaintext in a mode specified in the context */
void
-block_encrypt(RIJNDAEL_context *ctx, UINT8 *input, int inputlen,
- UINT8 *output, UINT8 *iv);
+block_encrypt(RIJNDAEL_context *ctx, uint8_t *input, int inputlen,
+ uint8_t *output, uint8_t *iv);
/* Decrypt a block of plaintext in a mode specified in the context */
void
-block_decrypt(RIJNDAEL_context *ctx, UINT8 *input, int inputlen,
- UINT8 *output, UINT8 *iv);
+block_decrypt(RIJNDAEL_context *ctx, uint8_t *input, int inputlen,
+ uint8_t *output, uint8_t *iv);
#endif /* RIJNDAEL_H */
