seven-zip 1.4.2 → 1.7.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 214494944476db8bda1b17d9b934ca5f67a744c2b9cb5f908c6483bb58a933a6
-  data.tar.gz: e1b6242c1b7ed0e4efa9d83f346023ce6ca0d82f102432ede254e1830c1ebaf3
+  metadata.gz: 92003adea0c0188011293976c804b1b00a44ade428d2fa7d50d52c92defffe9c
+  data.tar.gz: 181cda25e280aa0d12cdc33293f347c0bc22872e118fd134e7274f990fb11ce4
 SHA512:
-  metadata.gz: 72ed9a5c1ad17ee54b512e198c5539cc0402d17a69d502be3e5ccdea3b8f7d34af2316e64335a8d6e1d83d4c44f168c4504de5c344b6ec88a286db2e5af2495d
-  data.tar.gz: 3e63c60cf00e43cfa666aa9e16d1b2493f79ce0ca6d0cea5d6a062ed4ac5e5a2c5742fe8fcffeee36a20285adc6018c4accee013189db41010db99894d1571de
+  metadata.gz: 75ed7c6d0f6e81ec9886f91331098827ec27594835f6a05058e77631617e8735d3911c1b740d246f929df1f3447ec9c1a9136b7d16e6ea2e7a6f5e692bd21f41
+  data.tar.gz: ecb5bc3113234e0d3dc4e72800f63d4dec4c39f0a9776bc6b2935fc04db2ff4a5b0bfc8e506b9b16a475a8812b78ec902bd77d02902a5730f792e5b5945ae5d6

data/.github/workflows/rake.yml

@@ -0,0 +1,49 @@
+name: rake
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+
+permissions:
+  contents: write
+
+jobs:
+  rake-alpine:
+    name: Test on Ruby ${{ matrix.ruby.version }} ${{ matrix.os }}-${{ matrix.env.CC }}
+    runs-on: ubuntu-latest
+    env: ${{ matrix.env }}
+    container:
+      image: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+        - alpine:3.18
+        - alpine:3.16
+        env:
+        - CC: gcc
+          CXX: g++
+        - CC: clang
+          CXX: clang++
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Install Ruby
+      run: |
+        apk --no-cache --upgrade add build-base cmake git bash \
+        autoconf make binutils-dev pkgconfig tar ruby-dev clang
+
+    - name: Install Bundler
+      run: |
+        gem install bundler
+        bundle install
+
+    - run: bundle exec rake
+
+  rake:
+    needs: rake-alpine
+    uses: fontist/support/.github/workflows/rake.yml@main

data/.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: release
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        description: |
+          Next release version. Possible values: x.y.z, major, minor, patch (or pre|rc|etc).
+          Also, you can pass 'skip' to skip 'git tag' and do 'gem push' for the current version
+        required: true
+        default: 'skip'
+  repository_dispatch:
+    types: [ do-release ]
+
+jobs:
+  release:
+    uses: fontist/support/.github/workflows/release.yml@main
+    with:
+      next_version: ${{ github.event.inputs.next_version }}
+    secrets:
+      rubygems-api-key: ${{ secrets.FONTIST_CI_RUBYGEMS_API_KEY }}

data/README.md

@@ -61,7 +61,7 @@ File.open("filename.7z", "rb") do |file|
   SevenZipRuby::Reader.extract_all(file, "path_to_dir", { password: "Password String" })
 end
 ```
-
+If the password is invalid or missing no data will be returned for encrypted archive entries.
 
 ### Verify archives
 
@@ -99,7 +99,7 @@ SevenZipRuby supports the following platforms.
 
 SevenZipRuby supports the following Ruby engines on each platform.
 
-* MRI 2.3.0 and later
+* MRI 2.5.0 and later
 
 ## More examples
 
@@ -191,6 +191,17 @@ p(Time.now - start)
 LGPL license. Please refer to LICENSE.txt.
 
 ## Releases
+> The last version published at rubygems.org is 1.4.2
+> Should you need the latest version please install it from this repo
+* 1.6.2
+  - GCC 12 compatibility fix
+  - Tests for Ruby 3.2
+  - Test on Alpine Linux
+* 1.6.1
+  - [https://github.com/niloufar] 7z update to 19.00, p7zip update to 16.02
+* 1.5.0
+  - [https://github.com/niloufar] Secure loading of libraries to prevent DLL preloading attacks
+    https://support.microsoft.com/en-us/help/2389418/secure-loading-of-libraries-to-prevent-dll-preloading-attacks
 * 1.4.2
   - CI improvement, cleanup of debug output
 * 1.4.1

data/Rakefile

@@ -77,3 +77,5 @@ task :copy_binary do
     FileUtils.cp(src, dest) if (File.exist?(src))
   end
 end
+
+task default: %i[build_local spec]

data/ext/p7zip/C/7zBuf.h

@@ -1,14 +1,12 @@
 /* 7zBuf.h -- Byte Buffer
-2009-02-07 : Igor Pavlov : Public domain */
+2013-01-18 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_BUF_H
 #define __7Z_BUF_H
 
-#include "Types.h"
+#include "7zTypes.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+EXTERN_C_BEGIN
 
 typedef struct
 {
@@ -32,8 +30,6 @@ void DynBuf_SeekToBeg(CDynBuf *p);
 int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);
 void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
 
-#ifdef __cplusplus
-}
-#endif
+EXTERN_C_END
 
 #endif

data/ext/p7zip/C/7zBuf2.c

@@ -1,7 +1,10 @@
 /* 7zBuf2.c -- Byte Buffer
-2008-10-04 : Igor Pavlov : Public domain */
+2014-08-22 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include <string.h>
+
 #include "7zBuf.h"
 
 void DynBuf_Construct(CDynBuf *p)
@@ -31,8 +34,11 @@ int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc)
     alloc->Free(alloc, p->data);
     p->data = data;
   }
-  memcpy(p->data + p->pos, buf, size);
-  p->pos += size;
+  if (size != 0)
+  {
+    memcpy(p->data + p->pos, buf, size);
+    p->pos += size;
+  }
   return 1;
 }
 

data/ext/p7zip/C/7zCrc.c

@@ -1,5 +1,7 @@
-/* 7zCrc.c -- CRC32 calculation
-2009-11-23 : Igor Pavlov : Public domain */
+/* 7zCrc.c -- CRC32 init
+2015-03-10 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include "7zCrc.h"
 #include "CpuArch.h"
@@ -7,34 +9,28 @@
 #define kCrcPoly 0xEDB88320
 
 #ifdef MY_CPU_LE
-#define CRC_NUM_TABLES 8
+  #define CRC_NUM_TABLES 8
 #else
-#define CRC_NUM_TABLES 1
-#endif
-
-typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-static CRC_FUNC g_CrcUpdate;
-UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
+  #define CRC_NUM_TABLES 9
 
-#if CRC_NUM_TABLES == 1
+  #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
 
-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+  UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
+  UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#endif
 
-static UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  return v;
-}
+#ifndef MY_CPU_BE
+  UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
+  UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#endif
 
-#else
+typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
 
-UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
-UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
+CRC_FUNC g_CrcUpdateT4;
+CRC_FUNC g_CrcUpdateT8;
+CRC_FUNC g_CrcUpdate;
 
-#endif
+UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
 
 UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
 {
@@ -46,6 +42,17 @@ UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size)
   return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
 }
 
+#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  const Byte *pEnd = p + size;
+  for (; p != pEnd; p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  return v;
+}
+
 void MY_FAST_CALL CrcGenerateTable()
 {
   UInt32 i;
@@ -57,20 +64,65 @@ void MY_FAST_CALL CrcGenerateTable()
       r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
     g_CrcTable[i] = r;
   }
-  #if CRC_NUM_TABLES == 1
-  g_CrcUpdate = CrcUpdateT1;
-  #else
   for (; i < 256 * CRC_NUM_TABLES; i++)
   {
     UInt32 r = g_CrcTable[i - 256];
     g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
   }
-  g_CrcUpdate = CrcUpdateT4;
-/* FIXME
-  #ifdef MY_CPU_X86_OR_AMD64
-  if (!CPU_Is_InOrder())
-    g_CrcUpdate = CrcUpdateT8;
+
+  #if CRC_NUM_TABLES < 4
+  
+  g_CrcUpdate = CrcUpdateT1;
+  
+  #else
+ 
+  #ifdef MY_CPU_LE
+
+    g_CrcUpdateT4 = CrcUpdateT4;
+    g_CrcUpdate = CrcUpdateT4;
+
+    #if CRC_NUM_TABLES >= 8
+      g_CrcUpdateT8 = CrcUpdateT8;
+  
+      #ifdef MY_CPU_X86_OR_AMD64
+      if (!CPU_Is_InOrder())
+        g_CrcUpdate = CrcUpdateT8;
+      #endif
+    #endif
+
+  #else
+  {
+    #ifndef MY_CPU_BE
+    UInt32 k = 0x01020304;
+    const Byte *p = (const Byte *)&k;
+    if (p[0] == 4 && p[1] == 3)
+    {
+      g_CrcUpdateT4 = CrcUpdateT4;
+      g_CrcUpdate = CrcUpdateT4;
+      #if CRC_NUM_TABLES >= 8
+      g_CrcUpdateT8 = CrcUpdateT8;
+      // g_CrcUpdate = CrcUpdateT8;
+      #endif
+    }
+    else if (p[0] != 1 || p[1] != 2)
+      g_CrcUpdate = CrcUpdateT1;
+    else
+    #endif
+    {
+      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
+      {
+        UInt32 x = g_CrcTable[i - 256];
+        g_CrcTable[i] = CRC_UINT32_SWAP(x);
+      }
+      g_CrcUpdateT4 = CrcUpdateT1_BeT4;
+      g_CrcUpdate = CrcUpdateT1_BeT4;
+      #if CRC_NUM_TABLES >= 8
+      g_CrcUpdateT8 = CrcUpdateT1_BeT8;
+      // g_CrcUpdate = CrcUpdateT1_BeT8;
+      #endif
+    }
+  }
   #endif
-*/
+
   #endif
 }

data/ext/p7zip/C/7zCrc.h

@@ -1,10 +1,10 @@
 /* 7zCrc.h -- CRC32 calculation
-2009-11-21 : Igor Pavlov : Public domain */
+2013-01-18 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_CRC_H
 #define __7Z_CRC_H
 
-#include "Types.h"
+#include "7zTypes.h"
 
 EXTERN_C_BEGIN
 

data/ext/p7zip/C/7zCrcOpt.c

@@ -1,9 +1,11 @@
-/* 7zCrcOpt.c -- CRC32 calculation : optimized version
-2009-11-23 : Igor Pavlov : Public domain */
+/* 7zCrcOpt.c -- CRC32 calculation
+2015-03-01 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include "CpuArch.h"
 
-#ifdef MY_CPU_LE
+#ifndef MY_CPU_BE
 
 #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
 
@@ -16,10 +18,10 @@ UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const U
   {
     v ^= *(const UInt32 *)p;
     v =
-      table[0x300 + (v & 0xFF)] ^
-      table[0x200 + ((v >> 8) & 0xFF)] ^
-      table[0x100 + ((v >> 16) & 0xFF)] ^
-      table[0x000 + ((v >> 24))];
+          table[0x300 + ((v      ) & 0xFF)]
+        ^ table[0x200 + ((v >>  8) & 0xFF)]
+        ^ table[0x100 + ((v >> 16) & 0xFF)]
+        ^ table[0x000 + ((v >> 24))];
   }
   for (; size > 0; size--, p++)
     v = CRC_UPDATE_BYTE_2(v, *p);
@@ -28,7 +30,86 @@ UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const U
 
 UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
-  return CrcUpdateT4(v, data, size, table);
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  for (; size >= 8; size -= 8, p += 8)
+  {
+    UInt32 d;
+    v ^= *(const UInt32 *)p;
+    v =
+          table[0x700 + ((v      ) & 0xFF)]
+        ^ table[0x600 + ((v >>  8) & 0xFF)]
+        ^ table[0x500 + ((v >> 16) & 0xFF)]
+        ^ table[0x400 + ((v >> 24))];
+    d = *((const UInt32 *)p + 1);
+    v ^=
+          table[0x300 + ((d      ) & 0xFF)]
+        ^ table[0x200 + ((d >>  8) & 0xFF)]
+        ^ table[0x100 + ((d >> 16) & 0xFF)]
+        ^ table[0x000 + ((d >> 24))];
+  }
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  return v;
+}
+
+#endif
+
+
+#ifndef MY_CPU_LE
+
+#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
+
+#define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))
+
+UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  table += 0x100;
+  v = CRC_UINT32_SWAP(v);
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2_BE(v, *p);
+  for (; size >= 4; size -= 4, p += 4)
+  {
+    v ^= *(const UInt32 *)p;
+    v =
+          table[0x000 + ((v      ) & 0xFF)]
+        ^ table[0x100 + ((v >>  8) & 0xFF)]
+        ^ table[0x200 + ((v >> 16) & 0xFF)]
+        ^ table[0x300 + ((v >> 24))];
+  }
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2_BE(v, *p);
+  return CRC_UINT32_SWAP(v);
+}
+
+UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  table += 0x100;
+  v = CRC_UINT32_SWAP(v);
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2_BE(v, *p);
+  for (; size >= 8; size -= 8, p += 8)
+  {
+    UInt32 d;
+    v ^= *(const UInt32 *)p;
+    v =
+          table[0x400 + ((v      ) & 0xFF)]
+        ^ table[0x500 + ((v >>  8) & 0xFF)]
+        ^ table[0x600 + ((v >> 16) & 0xFF)]
+        ^ table[0x700 + ((v >> 24))];
+    d = *((const UInt32 *)p + 1);
+    v ^=
+          table[0x000 + ((d      ) & 0xFF)]
+        ^ table[0x100 + ((d >>  8) & 0xFF)]
+        ^ table[0x200 + ((d >> 16) & 0xFF)]
+        ^ table[0x300 + ((d >> 24))];
+  }
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2_BE(v, *p);
+  return CRC_UINT32_SWAP(v);
 }
 
 #endif

data/ext/p7zip/C/7zStream.c

@@ -1,9 +1,11 @@
 /* 7zStream.c -- 7z Stream functions
-2010-03-11 : Igor Pavlov : Public domain */
+2013-11-12 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include <string.h>
 
-#include "Types.h"
+#include "7zTypes.h"
 
 SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)
 {

data/ext/p7zip/C/{Types.h → 7zTypes.h}

@@ -1,15 +1,15 @@
-/* Types.h -- Basic types
-2010-10-09 : Igor Pavlov : Public domain */
+/* 7zTypes.h -- Basic types
+2013-11-12 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_TYPES_H
 #define __7Z_TYPES_H
 
-#include <stddef.h>
-
 #ifdef _WIN32
-#include <windows.h>
+/* #include <windows.h> */
 #endif
 
+#include <stddef.h>
+
 #ifndef EXTERN_C_BEGIN
 #ifdef __cplusplus
 #define EXTERN_C_BEGIN extern "C" {
@@ -43,7 +43,8 @@ EXTERN_C_BEGIN
 typedef int SRes;
 
 #ifdef _WIN32
-typedef DWORD WRes;
+/* typedef DWORD WRes; */
+typedef unsigned WRes;
 #else
 typedef int WRes;
 #endif
@@ -116,6 +117,7 @@ typedef int Bool;
 
 #else
 
+#define MY_NO_INLINE
 #define MY_CDECL
 #define MY_FAST_CALL
 

data/ext/p7zip/C/7zVersion.h

@@ -1,7 +1,22 @@
-#define MY_VER_MAJOR 9
-#define MY_VER_MINOR 20
+#define MY_VER_MAJOR 16
+#define MY_VER_MINOR 02
 #define MY_VER_BUILD 0
-#define MY_VERSION "9.20"
-#define MY_DATE "2010-11-18"
-#define MY_COPYRIGHT ": Igor Pavlov : Public domain"
-#define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE
+#define MY_VERSION_NUMBERS "16.02"
+#define MY_VERSION "16.02"
+#define MY_DATE "2016-05-21"
+#undef MY_COPYRIGHT
+#undef MY_VERSION_COPYRIGHT_DATE
+#define MY_AUTHOR_NAME "Igor Pavlov"
+#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
+#define MY_COPYRIGHT_CR "Copyright (c) 1999-2016 Igor Pavlov"
+
+#ifdef USE_COPYRIGHT_CR
+  #define MY_COPYRIGHT MY_COPYRIGHT_CR
+#else
+  #define MY_COPYRIGHT MY_COPYRIGHT_PD
+#endif
+
+#define MY_VERSION_COPYRIGHT_DATE MY_VERSION " : " MY_COPYRIGHT " : " MY_DATE
+
+#define P7ZIP_VERSION "16.02"
+

data/ext/p7zip/C/Aes.c

@@ -1,11 +1,13 @@
 /* Aes.c -- AES encryption / decryption
-2009-11-23 : Igor Pavlov : Public domain */
+2016-05-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include "Aes.h"
 #include "CpuArch.h"
 
 static UInt32 T[256 * 4];
-static Byte Sbox[256] = {
+static const Byte Sbox[256] = {
   0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
   0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
   0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
@@ -38,7 +40,7 @@ AES_CODE_FUNC g_AesCtr_Code;
 static UInt32 D[256 * 4];
 static Byte InvS[256];
 
-static Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
+static const Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
 
 #define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
 
@@ -54,6 +56,7 @@ void AesGenTables(void)
   unsigned i;
   for (i = 0; i < 256; i++)
     InvS[Sbox[i]] = (Byte)i;
+  
   for (i = 0; i < 256; i++)
   {
     {
@@ -80,11 +83,13 @@ void AesGenTables(void)
       D[0x300 + i] = Ui32(a9, aD, aB, aE);
     }
   }
+  
   g_AesCbc_Encode = AesCbc_Encode;
   g_AesCbc_Decode = AesCbc_Decode;
   g_AesCtr_Code = AesCtr_Code;
-/* FIXME
+  
   #ifdef MY_CPU_X86_OR_AMD64
+  #ifdef _7ZIP_ASM
   if (CPU_Is_Aes_Supported())
   {
     g_AesCbc_Encode = AesCbc_Encode_Intel;
@@ -92,37 +97,41 @@ void AesGenTables(void)
     g_AesCtr_Code = AesCtr_Code_Intel;
   }
   #endif
-*/
+  #endif
 }
 
+
 #define HT(i, x, s) (T + (x << 8))[gb ## x(s[(i + x) & 3])]
+
 #define HT4(m, i, s, p) m[i] = \
     HT(i, 0, s) ^ \
     HT(i, 1, s) ^ \
     HT(i, 2, s) ^ \
     HT(i, 3, s) ^ w[p + i]
-/* such order (2031) in HT16 is for VC6/K8 speed optimization) */
+
 #define HT16(m, s, p) \
-    HT4(m, 2, s, p); \
     HT4(m, 0, s, p); \
-    HT4(m, 3, s, p); \
     HT4(m, 1, s, p); \
+    HT4(m, 2, s, p); \
+    HT4(m, 3, s, p); \
 
 #define FT(i, x) Sbox[gb ## x(m[(i + x) & 3])]
 #define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
 
+
 #define HD(i, x, s) (D + (x << 8))[gb ## x(s[(i - x) & 3])]
+
 #define HD4(m, i, s, p) m[i] = \
     HD(i, 0, s) ^ \
     HD(i, 1, s) ^ \
     HD(i, 2, s) ^ \
     HD(i, 3, s) ^ w[p + i];
-/* such order (0231) in HD16 is for VC6/K8 speed optimization) */
+
 #define HD16(m, s, p) \
     HD4(m, 0, s, p); \
+    HD4(m, 1, s, p); \
     HD4(m, 2, s, p); \
     HD4(m, 3, s, p); \
-    HD4(m, 1, s, p); \
 
 #define FD(i, x) InvS[gb ## x(m[(i - x) & 3])]
 #define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
@@ -160,16 +169,16 @@ void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
   {
     UInt32 r = w[i];
     w[i] =
-      D[        Sbox[gb0(r)]] ^
-      D[0x100 + Sbox[gb1(r)]] ^
-      D[0x200 + Sbox[gb2(r)]] ^
-      D[0x300 + Sbox[gb3(r)]];
+      D[        (unsigned)Sbox[gb0(r)]] ^
+      D[0x100 + (unsigned)Sbox[gb1(r)]] ^
+      D[0x200 + (unsigned)Sbox[gb2(r)]] ^
+      D[0x300 + (unsigned)Sbox[gb3(r)]];
   }
 }
 
 /* Aes_Encode and Aes_Decode functions work with little-endian words.
   src and dest are pointers to 4 UInt32 words.
-  arc and dest can point to same block */
+  src and dest can point to same block */
 
 static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
 {
@@ -271,13 +280,17 @@ void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
     UInt32 temp[4];
     Byte buf[16];
     int i;
+
     if (++p[0] == 0)
       p[1]++;
+    
     Aes_Encode(p + 4, temp, p);
+    
     SetUi32(buf,      temp[0]);
     SetUi32(buf + 4,  temp[1]);
     SetUi32(buf + 8,  temp[2]);
     SetUi32(buf + 12, temp[3]);
+    
     for (i = 0; i < 16; i++)
       *data++ ^= buf[i];
   }