Refactored for latest version of VaporLibrary

* Updated for VaporLibrary 4.66.1

Author: DBenYaakov

Package.swift

@@ -1,22 +1,22 @@
-// swift-tools-version:5.5
+// swift-tools-version:5.7
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
 
 let package = Package(
   name: "VaporShell",
   dependencies: [
-    
+      .package(url: "https://github.com/apple/swift-atomics.git", from: "1.0.2")
   ],
   targets: [
     // Targets are the basic building blocks of a package. A target can define a module or a test suite.
     // Targets can depend on other targets in this package, and on products in packages which this package depends on.
     .target(name: "CBase32"),
-    .target(name: "CBcrypt"),
-    
+    .target(name: "CVaporBcrypt"),
     .executableTarget(name: "VaporShell", dependencies: [
+                                            .product(name: "Atomics", package: "swift-atomics"),
                                             .target(name: "CBase32"),
-                                            .target(name: "CBcrypt")
+                                            .target(name: "CVaporBcrypt")
                                           ])
   ]
 )

Package.swift.doc

@@ -42,15 +42,14 @@
 
 char   *bcrypt_gensalt(u_int8_t);
 
-int encode_base64(char *, const u_int8_t *, size_t);
 static int decode_base64(u_int8_t *, size_t, const char *);
 
 /*
  * the core bcrypt function
  */
 int
-bcrypt_hashpass(const char *key, const char *salt, char *encrypted,
-                size_t encryptedlen)
+vapor_bcrypt_hashpass(const char *key, const char *salt, char *encrypted,
+                      size_t encryptedlen)
 {
     blf_ctx state;
     u_int32_t rounds, i, k;
@@ -117,22 +116,22 @@ bcrypt_hashpass(const char *key, const char *salt, char *encrypted,
     salt_len = BCRYPT_MAXSALT;
 
     /* Setting up S-Boxes and Subkeys */
-    Blowfish_initstate(&state);
-    Blowfish_expandstate(&state, csalt, salt_len,
-                         (u_int8_t *) key, key_len);
+    Vapor_Blowfish_initstate(&state);
+    Vapor_Blowfish_expandstate(&state, csalt, salt_len,
+                               (u_int8_t *) key, key_len);
     for (k = 0; k < rounds; k++) {
-        Blowfish_expand0state(&state, (u_int8_t *) key, key_len);
-        Blowfish_expand0state(&state, csalt, salt_len);
+        Vapor_Blowfish_expand0state(&state, (u_int8_t *) key, key_len);
+        Vapor_Blowfish_expand0state(&state, csalt, salt_len);
     }
 
     /* This can be precomputed later */
     j = 0;
     for (i = 0; i < BCRYPT_WORDS; i++)
-        cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_WORDS, &j);
+        cdata[i] = Vapor_Blowfish_stream2word(ciphertext, 4 * BCRYPT_WORDS, &j);
 
     /* Now do the encryption */
     for (k = 0; k < 64; k++)
-        blf_enc(&state, cdata, BCRYPT_WORDS / 2);
+        vapor_blf_enc(&state, cdata, BCRYPT_WORDS / 2);
 
     for (i = 0; i < BCRYPT_WORDS; i++) {
         ciphertext[4 * i + 3] = cdata[i] & 0xff;
@@ -146,8 +145,8 @@ bcrypt_hashpass(const char *key, const char *salt, char *encrypted,
 
 
     snprintf(encrypted, 8, "$2%c$%2.2u$", minor, logr);
-    encode_base64(encrypted + 7, csalt, BCRYPT_MAXSALT);
-    encode_base64(encrypted + 7 + 22, ciphertext, 4 * BCRYPT_WORDS - 1);
+    vapor_encode_base64(encrypted + 7, csalt, BCRYPT_MAXSALT);
+    vapor_encode_base64(encrypted + 7 + 22, ciphertext, 4 * BCRYPT_WORDS - 1);
     explicit_bzero(&state, sizeof(state));
     explicit_bzero(ciphertext, sizeof(ciphertext));
     explicit_bzero(csalt, sizeof(csalt));
@@ -229,7 +228,7 @@ decode_base64(u_int8_t *buffer, size_t len, const char *b64data)
  * This works without = padding.
  */
 int
-encode_base64(char *b64buffer, const u_int8_t *data, size_t len)
+vapor_encode_base64(char *b64buffer, const u_int8_t *data, size_t len)
 {
     u_int8_t *bp = (u_int8_t *)b64buffer;
     const u_int8_t *p = data;

Package.swift.dynamic

@@ -35,5 +35,5 @@ typedef uint64_t u_int64_t;
 #define    BCRYPT_HASHSPACE    61
 
 
-int bcrypt_hashpass(const char *key, const char *salt, char *encrypted, size_t encryptedlen);
-int encode_base64(char *, const u_int8_t *, size_t);
+int vapor_bcrypt_hashpass(const char *key, const char *salt, char *encrypted, size_t encryptedlen);
+int vapor_encode_base64(char *, const u_int8_t *, size_t);

Sources/CBcrypt/include/module.modulemap

@@ -61,7 +61,7 @@
 #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n])
 
 void
-Blowfish_encipher(blf_ctx *c, u_int32_t *x)
+Vapor_Blowfish_encipher(blf_ctx *c, u_int32_t *x)
 {
     u_int32_t Xl;
     u_int32_t Xr;
@@ -86,7 +86,7 @@ Blowfish_encipher(blf_ctx *c, u_int32_t *x)
 }
 
 void
-Blowfish_decipher(blf_ctx *c, u_int32_t *x)
+Vapor_Blowfish_decipher(blf_ctx *c, u_int32_t *x)
 {
     u_int32_t Xl;
     u_int32_t Xr;
@@ -111,7 +111,7 @@ Blowfish_decipher(blf_ctx *c, u_int32_t *x)
 }
 
 void
-Blowfish_initstate(blf_ctx *c)
+Vapor_Blowfish_initstate(blf_ctx *c)
 {
     /* P-box and S-box tables initialized with digits of Pi */
 
@@ -391,8 +391,8 @@ Blowfish_initstate(blf_ctx *c)
 }
 
 u_int32_t
-Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes,
-                     u_int16_t *current)
+Vapor_Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes,
+                           u_int16_t *current)
 {
     u_int8_t i;
     u_int16_t j;
@@ -412,7 +412,7 @@ Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes,
 }
 
 void
-Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
+Vapor_Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
 {
     u_int16_t i;
     u_int16_t j;
@@ -423,23 +423,23 @@ Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
     j = 0;
     for (i = 0; i < BLF_N + 2; i++) {
         /* Extract 4 int8 to 1 int32 from keystream */
-        temp = Blowfish_stream2word(key, keybytes, &j);
+        temp = Vapor_Blowfish_stream2word(key, keybytes, &j);
         c->P[i] = c->P[i] ^ temp;
     }
 
     j = 0;
     data[0] = 0x00000000;
     data[1] = 0x00000000;
     for (i = 0; i < BLF_N + 2; i += 2) {
-        Blowfish_encipher(c, data);
+        Vapor_Blowfish_encipher(c, data);
 
         c->P[i] = data[0];
         c->P[i + 1] = data[1];
     }
 
     for (i = 0; i < 4; i++) {
         for (k = 0; k < 256; k += 2) {
-            Blowfish_encipher(c, data);
+            Vapor_Blowfish_encipher(c, data);
 
             c->S[i][k] = data[0];
             c->S[i][k + 1] = data[1];
@@ -449,8 +449,8 @@ Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes)
 
 
 void
-Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
-                     const u_int8_t *key, u_int16_t keybytes)
+Vapor_Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
+                           const u_int8_t *key, u_int16_t keybytes)
 {
     u_int16_t i;
     u_int16_t j;
@@ -461,27 +461,27 @@ Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
     j = 0;
     for (i = 0; i < BLF_N + 2; i++) {
         /* Extract 4 int8 to 1 int32 from keystream */
-        temp = Blowfish_stream2word(key, keybytes, &j);
+        temp = Vapor_Blowfish_stream2word(key, keybytes, &j);
         c->P[i] = c->P[i] ^ temp;
     }
 
     j = 0;
     d[0] = 0x00000000;
     d[1] = 0x00000000;
     for (i = 0; i < BLF_N + 2; i += 2) {
-        d[0] ^= Blowfish_stream2word(data, databytes, &j);
-        d[1] ^= Blowfish_stream2word(data, databytes, &j);
-        Blowfish_encipher(c, d);
+        d[0] ^= Vapor_Blowfish_stream2word(data, databytes, &j);
+        d[1] ^= Vapor_Blowfish_stream2word(data, databytes, &j);
+        Vapor_Blowfish_encipher(c, d);
 
         c->P[i] = d[0];
         c->P[i + 1] = d[1];
     }
 
     for (i = 0; i < 4; i++) {
         for (k = 0; k < 256; k += 2) {
-            d[0]^= Blowfish_stream2word(data, databytes, &j);
-            d[1] ^= Blowfish_stream2word(data, databytes, &j);
-            Blowfish_encipher(c, d);
+            d[0] ^= Vapor_Blowfish_stream2word(data, databytes, &j);
+            d[1] ^= Vapor_Blowfish_stream2word(data, databytes, &j);
+            Vapor_Blowfish_encipher(c, d);
 
             c->S[i][k] = d[0];
             c->S[i][k + 1] = d[1];
@@ -491,43 +491,43 @@ Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes,
 }
 
 void
-blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len)
+vapor_blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len)
 {
     /* Initialize S-boxes and subkeys with Pi */
-    Blowfish_initstate(c);
+    Vapor_Blowfish_initstate(c);
 
     /* Transform S-boxes and subkeys with key */
-    Blowfish_expand0state(c, k, len);
+    Vapor_Blowfish_expand0state(c, k, len);
 }
 
 void
-blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+vapor_blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
 {
     u_int32_t *d;
     u_int16_t i;
 
     d = data;
     for (i = 0; i < blocks; i++) {
-        Blowfish_encipher(c, d);
+        Vapor_Blowfish_encipher(c, d);
         d += 2;
     }
 }
 
 void
-blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
+vapor_blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks)
 {
     u_int32_t *d;
     u_int16_t i;
 
     d = data;
     for (i = 0; i < blocks; i++) {
-        Blowfish_decipher(c, d);
+        Vapor_Blowfish_decipher(c, d);
         d += 2;
     }
 }
 
 void
-blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+vapor_blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
 {
     u_int32_t l, r, d[2];
     u_int32_t i;
@@ -537,7 +537,7 @@ blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         d[0] = l;
         d[1] = r;
-        Blowfish_encipher(c, d);
+        Vapor_Blowfish_encipher(c, d);
         l = d[0];
         r = d[1];
         data[0] = l >> 24 & 0xff;
@@ -553,7 +553,7 @@ blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
 }
 
 void
-blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
+vapor_blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
 {
     u_int32_t l, r, d[2];
     u_int32_t i;
@@ -563,7 +563,7 @@ blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         d[0] = l;
         d[1] = r;
-        Blowfish_decipher(c, d);
+        Vapor_Blowfish_decipher(c, d);
         l = d[0];
         r = d[1];
         data[0] = l >> 24 & 0xff;
@@ -579,7 +579,7 @@ blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len)
 }
 
 void
-blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
+vapor_blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
 {
     u_int32_t l, r, d[2];
     u_int32_t i, j;
@@ -591,7 +591,7 @@ blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         d[0] = l;
         d[1] = r;
-        Blowfish_encipher(c, d);
+        Vapor_Blowfish_encipher(c, d);
         l = d[0];
         r = d[1];
         data[0] = l >> 24 & 0xff;
@@ -608,7 +608,7 @@ blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len)
 }
 
 void
-blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
+vapor_blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
 {
     u_int32_t l, r, d[2];
     u_int8_t *iv;
@@ -621,7 +621,7 @@ blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
         r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
         d[0] = l;
         d[1] = r;
-        Blowfish_decipher(c, d);
+        Vapor_Blowfish_decipher(c, d);
         l = d[0];
         r = d[1];
         data[0] = l >> 24 & 0xff;
@@ -641,7 +641,7 @@ blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len)
     r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7];
     d[0] = l;
     d[1] = r;
-    Blowfish_decipher(c, d);
+    Vapor_Blowfish_decipher(c, d);
     l = d[0];
     r = d[1];
     data[0] = l >> 24 & 0xff;