Merge pull request #2 from salishseasoftware/develop

Rename `cipher` parameter to `token`.

Author: hishma

.github/workflows/swift.yml

@@ -0,0 +1,19 @@
+name: Swift
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    branches: [ develop ]
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: swift build --disable-sandbox -v
+    - name: Run tests
+      run: swift test -v

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 0.1.2
+
+### Changed
+
+* Rename `cipher` parameter to `token`.
+
 ## 0.1.1
 
 Initial release

README.md

@@ -13,7 +13,7 @@ Inspired by [twenty3/Obfuscator](https://github.com/twenty3/Obfuscator), and the
 
 This package contains both a library and command line tool.
 
-Use the `obfuscate` command line tool to encrypt your secret token. It generates both a cipher and a key (A.K.A. salt) you can use to reveal the original value.
+Use the `obfuscate` command line tool to encrypt your secret token. It generates both a token and a key (A.K.A. salt) you can use to reveal the original value.
 
 Include the library in your application to decode the value at runtime.
 
@@ -72,7 +72,7 @@ the original value using the obfuscates string and the salt.
 You can include the obfuscated string in your applications source code and provide the key
 through some type of configuration method (ENV, XCConfig file, etc).
 
-Then use the `Obfuscator` library to decrypt the cipher at runtime when needed.
+Then use the `Obfuscator` library to decrypt the token at runtime when needed.
 
 The important bit is that your original secret should not be present in your source code,
 config files, or your SCM system.
@@ -100,8 +100,8 @@ SUBCOMMANDS:
 ```
 OVERVIEW: Obfuscates a string.
 
-Generates a cipher from the provided string, along with a key that can 
-be used to decrypt the cipher, and reveal the original value.
+Generates a token from the provided string, along with a key that can 
+be used to decrypt the token, and reveal the original value.
 
 USAGE: obfuscate encrypt <string>
 
@@ -117,12 +117,12 @@ OPTIONS:
 ```
 OVERVIEW: Reveals an obfuscated string.
 
-Decrypts the provided cipher using the key to reveal the original value.
+Decrypts the provided token using the key to reveal the original value.
 
-USAGE: obfuscate decrypt --cipher <cipher> --key <key>
+USAGE: obfuscate decrypt --token <token> --key <key>
 
 OPTIONS:
-  -c, --cipher <cipher>   The obfuscated string 
+  -t, --token <token>   The obfuscated string 
   -k, --key <key>         Secret key 
   -h, --help              Show help information.
 ```
@@ -146,17 +146,17 @@ An error or type `ObfuscatorError.encryptionFailure` if the encryption fails.
 
 __Returns__
 
-A `(String, String)` tuple consisting of the obfuscated string (cipher) and a randomly generated salt (key) used to perform the encryption.
+A `(String, String)` tuple consisting of the obfuscated string (token) and a randomly generated salt (key) used to perform the encryption.
 
 ### decrypt
 
-`decrypt(cipher:,key:)`
+`decrypt(token:,key:)`
 
  Reveals the original value of an encrypted string.
 
 __Parameters__
 
-- `cipher:` The encrypted string.
+- `token:` The encrypted string.
 - `key:` The salt used to encrypt the string.
 
 __Throws__
@@ -187,6 +187,3 @@ let package = Package(
 )
 ```
 
-
-
-

Sources/Obfuscator/obfuscator.swift

@@ -10,38 +10,38 @@ public class Obfuscator {
     /// Encrypt a string
     /// - Parameter secret: The secret you want to encrypt
     /// - Throws: A ObfuscatorError.encryptionFailure if the encryption fails.
-    /// - Returns: A tuple consisting of the encrypted string (cipher) and a
+    /// - Returns: A tuple consisting of the encrypted string (token) and a
     ///     randomly generated salt (key) used to perform the encryption.
-    public static func encrypt(_ secret: String) throws -> (cipher: String, key: String) {
+    public static func encrypt(_ secret: String) throws -> (token: String, key: String) {
         let key = randomString(length: secret.lengthOfBytes(using: .utf8))
         let salt = [UInt8](key.utf8)
         let bytes = [UInt8](secret.utf8)
 
         // make sure salt and secret are the same length
         guard bytes.count == salt.count else { throw ObfuscatorError.encryptionFailure }
 
-        let encrypted = zip(bytes, salt)
+        let cipher = zip(bytes, salt)
             .map { $0 ^ $1 }
             .map { String(describing: $0) }
             .joined(separator: delimiter)
             .data(using: .utf8)?
             .base64EncodedString()
 
-        guard let cipher = encrypted else { throw ObfuscatorError.encryptionFailure }
+        guard let token = cipher else { throw ObfuscatorError.encryptionFailure }
 
-        return (cipher, key)
+        return (token, key)
     }
 
 
     /// Reveals the original value of an encrypted string
     /// - Parameters:
-    ///   - cipher: The encrytped string.
+    ///   - token: The encrytped string.
     ///   - key: The key (A.K.A. salt) used to encrypt the orignal.
     /// - Throws: An ObfuscatorError.decryptionFailure if the decryption fails.
     /// - Returns: The original value.
-    public static func decrypt(cipher: String, key: String) throws -> String {
+    public static func decrypt(token: String, key: String) throws -> String {
         guard
-            let data = Data.init(base64Encoded: cipher),
+            let data = Data.init(base64Encoded: token),
             let byteString = String.init(bytes: data, encoding: .utf8)
         else {
             throw ObfuscatorError.decryptionFailure

Sources/obfuscate/Decrypt.swift

@@ -6,18 +6,18 @@ extension Obfuscate {
     struct Decrypt: ParsableCommand {
         static var configuration = CommandConfiguration(
             abstract: "Reveals an obfuscated string.",
-            discussion: "Decrypts the provided cipher using the key to reveal the original value."
+            discussion: "Decrypts the provided token using the key to reveal the original value."
         )
 
         @Option(name: .shortAndLong, help: "The obfuscated string")
-        var cipher: String
+        var token: String
 
         @Option(name: .shortAndLong, help: "Secret key")
         var key: String
 
         mutating func run() {
             do {
-                let result = try Obfuscator.decrypt(cipher: cipher, key: key)
+                let result = try Obfuscator.decrypt(token: token, key: key)
                 print(result)
             } catch {
                 Self.exit(withError: error)

Sources/obfuscate/Encrypt.swift

@@ -7,7 +7,7 @@ extension Obfuscate {
         static var configuration = CommandConfiguration(
             abstract: "Obfuscates a string.",
             discussion: """
-            Generates a cipher from the provided string, along with a key that can be used to decrypt the cipher,
+            Generates a token from the provided string, along with a key that can be used to decrypt the token,
             and reveal the original value.
             """
         )
@@ -16,8 +16,8 @@ extension Obfuscate {
 
         mutating func run() {
             do {
-                let (cipher, key) = try Obfuscator.encrypt(string)
-                print("cipher: \(cipher)")
+                let (token, key) = try Obfuscator.encrypt(string)
+                print("token: \(token)")
                 print("key: \(key)")
             } catch {
                 Self.exit(withError: error)

Sources/obfuscate/main.swift

@@ -13,7 +13,7 @@ struct Obfuscate: ParsableCommand {
         You can include the obfuscated string in your applications source code and provide the key
         through some type of configuration method (ENV, XCConfig file, etc).
 
-        Then use the `Obfuscator` library to decrypt the cipher at runtime when needed.
+        Then use the `Obfuscator` library to decrypt the token at runtime when needed.
 
         The important bit is that your original secret should not be present in your source code,
         config files, or your SCM system.

Tests/ObfuscatorTests/ObsfucatorTests.swift

@@ -6,30 +6,30 @@ final class ObfuscatorTests: XCTestCase {
     let sekret = "super duper top sekret 💩!"
 
     func testEncrypt() throws {
-        let (cipher, key) = try Obfuscator.encrypt(sekret)
-        XCTAssertFalse(cipher.isEmpty)
+        let (token, key) = try Obfuscator.encrypt(sekret)
+        XCTAssertFalse(token.isEmpty)
         XCTAssertFalse(key.isEmpty)
-        XCTAssertNotEqual(cipher, key)
+        XCTAssertNotEqual(token, key)
         XCTAssertNotEqual(sekret, key)
     }
 
     func testDecrypt() throws {
-        let (cipher, key) = try Obfuscator.encrypt(sekret)
-        let decrypted = try Obfuscator.decrypt(cipher: cipher, key: key)
+        let (token, key) = try Obfuscator.encrypt(sekret)
+        let decrypted = try Obfuscator.decrypt(token: token, key: key)
         XCTAssertNotNil(decrypted)
         XCTAssertEqual(sekret, decrypted)
     }
 
     func testDecryptInvalidKey() throws {
-        let (cipher, _) = try Obfuscator.encrypt(sekret)
-        XCTAssertThrowsError(try Obfuscator.decrypt(cipher: cipher, key: "INVALID")) { (errorThrown) in
+        let (token, _) = try Obfuscator.encrypt(sekret)
+        XCTAssertThrowsError(try Obfuscator.decrypt(token: token, key: "INVALID")) { (errorThrown) in
             XCTAssertEqual(errorThrown as? Obfuscator.ObfuscatorError, Obfuscator.ObfuscatorError.decryptionFailure)
         }
     }
 
     func testDecryptInvalidSalt() throws {
         let (_, key) = try Obfuscator.encrypt(sekret)
-        XCTAssertThrowsError(try Obfuscator.decrypt(cipher: "INVALID", key: key)) { (errorThrown) in
+        XCTAssertThrowsError(try Obfuscator.decrypt(token: "INVALID", key: key)) { (errorThrown) in
             XCTAssertEqual(errorThrown as? Obfuscator.ObfuscatorError, Obfuscator.ObfuscatorError.decryptionFailure)
         }
     }