Core library: model, envelope, generator !7
25 files changed, +12524 −0
Layout: unified · split
.gitbay/ci.yml added +52
| @@ -0,0 +1,52 @@ | ||
| 1 | # The runner is Debian 13, root, no docker. apt state does not survive between | |
| 2 | # builds; $HOME does, so the toolchain tarball is fetched and verified once. | |
| 3 | # swift-keys.asc is https://www.swift.org/keys/all-keys.asc, committed because the | |
| 4 | # runner cannot fetch it intact. | |
| 5 | # Each step runs in its own `sh -c`, so the install block is repeated per job. | |
| 6 | jobs: | |
| 7 | build: | |
| 8 | steps: | |
| 9 | - | | |
| 10 | set -eu | |
| 11 | export DEBIAN_FRONTEND=noninteractive | |
| 12 | apt-get -qq update >/dev/null | |
| 13 | apt-get -qq install -y binutils-gold curl gpg libicu-dev libcurl4-openssl-dev libedit-dev libsqlite3-dev libncurses-dev libpython3-dev libxml2-dev pkg-config uuid-dev tzdata git gcc libstdc++-14-dev >/dev/null | |
| 14 | SWIFT="$HOME/swift-6.4.0-RELEASE-debian13" | |
| 15 | if [ ! -x "$SWIFT/usr/bin/swift" ]; then | |
| 16 | base="https://download.swift.org/swift-6.4.0-release/debian13/swift-6.4.0-RELEASE/swift-6.4.0-RELEASE-debian13.tar.gz" | |
| 17 | work="$(mktemp -d)" | |
| 18 | curl -fsSL "$base" -o "$work/swift.tar.gz" "$base.sig" -o "$work/swift.tar.gz.sig" | |
| 19 | export GNUPGHOME="$work/gnupg"; mkdir -m 700 "$GNUPGHOME" | |
| 20 | gpg --batch --quiet --import .gitbay/swift-keys.asc | |
| 21 | gpg --batch --verify "$work/swift.tar.gz.sig" "$work/swift.tar.gz" | |
| 22 | tar -xzf "$work/swift.tar.gz" -C "$work" | |
| 23 | mv "$work/swift-6.4.0-RELEASE-debian13" "$SWIFT" || true | |
| 24 | rm -rf "$work" | |
| 25 | fi | |
| 26 | export PATH="$SWIFT/usr/bin:$PATH" | |
| 27 | swift --version | |
| 28 | swift format lint --strict --recursive Sources Tests Package.swift | |
| 29 | swift build | |
| 30 | test: | |
| 31 | steps: | |
| 32 | - | | |
| 33 | set -eu | |
| 34 | export DEBIAN_FRONTEND=noninteractive | |
| 35 | apt-get -qq update >/dev/null | |
| 36 | apt-get -qq install -y binutils-gold curl gpg libicu-dev libcurl4-openssl-dev libedit-dev libsqlite3-dev libncurses-dev libpython3-dev libxml2-dev pkg-config uuid-dev tzdata git gcc libstdc++-14-dev >/dev/null | |
| 37 | SWIFT="$HOME/swift-6.4.0-RELEASE-debian13" | |
| 38 | if [ ! -x "$SWIFT/usr/bin/swift" ]; then | |
| 39 | base="https://download.swift.org/swift-6.4.0-release/debian13/swift-6.4.0-RELEASE/swift-6.4.0-RELEASE-debian13.tar.gz" | |
| 40 | work="$(mktemp -d)" | |
| 41 | curl -fsSL "$base" -o "$work/swift.tar.gz" "$base.sig" -o "$work/swift.tar.gz.sig" | |
| 42 | export GNUPGHOME="$work/gnupg"; mkdir -m 700 "$GNUPGHOME" | |
| 43 | gpg --batch --quiet --import .gitbay/swift-keys.asc | |
| 44 | gpg --batch --verify "$work/swift.tar.gz.sig" "$work/swift.tar.gz" | |
| 45 | tar -xzf "$work/swift.tar.gz" -C "$work" | |
| 46 | mv "$work/swift-6.4.0-RELEASE-debian13" "$SWIFT" || true | |
| 47 | rm -rf "$work" | |
| 48 | fi | |
| 49 | export PATH="$SWIFT/usr/bin:$PATH" | |
| 50 | swift test | |
| 51 | paths-ignore: | |
| 52 | - docs/** | |
.gitbay/swift-keys.asc added +390
| @@ -0,0 +1,390 @@ | ||
| 1 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 2 | Version: GnuPG v2.0.14 (GNU/Linux) | |
| 3 | ||
| 4 | mQINBFZNNIwBEADNFSwCfUUyXZujWzQCqYLlvRwZkuMUcJQH4NRwC/an9KwilFrz | |
| 5 | pf/+atZFSciMx5R9vOG2odWbwBYU7t8XEd/NYCgyTwMNxAFkuaN1E0b/3mOWwbT5 | |
| 6 | 91HziQNy0jDUlM28370pyv0rBTHvPbBQlo7BxJbwQXL3rs3KObAnhTG51aLztGds | |
| 7 | OTxZDdpNY07dPGKJevP61l35yZI40tUmCKn/z4sLmX+DoUUplA35SMRnvQjd/pGF | |
| 8 | 9BTAFzLfsbN0caBixy++0ZIyK9ep1dezhqisUndE/rNk8KPNAM5zeFA1onzEEGFc | |
| 9 | gk4iZ0N/S7dVb7N4Uhn8C/87E9yUkrzO0Kl+p2zumORiqIvkv9vtHMaKa6rBP/vI | |
| 10 | iG02eiLmaWdDkg7afpJjnC6WrrJoBe/lbDAYrbD5eR4KGHdxMtAdh0sYZrZR8T4m | |
| 11 | gI6alC8PjYY22wiNLeekATobDu5JVQna0525L57gpbLOhSjXk/69HHw/l7d/e6br | |
| 12 | 35rmMYGJd/9Q1w/4gMo8tX5m1WaoQxac4tZs8bBRKNP7YJkHmwfVG21h0KA91yFA | |
| 13 | l1BMe9U+gomfqRoBCRXGDl1mHmyGqu59JjpYEP04Xu2dLCu8yt/HHYirMdsKIvHT | |
| 14 | WKm6EvuQ4vFTQbPcdrMltL9yf8xG8EL0oDIbaSAnHI+sY+C30i0S557G3wARAQAB | |
| 15 | tD9Td2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzEgPHN3aWZ0LWluZnJhc3Ry | |
| 16 | dWN0dXJlQHN3aWZ0Lm9yZz6JAj0EEwEKACcFAlZNNIwCGwMFCQPCZwAFCwkIBwMF | |
| 17 | FQoJCAsFFgIDAQACHgECF4AACgkQ1EHJd0ErN63tFA/+N3ANSFFc2FcdimzisPOv | |
| 18 | wBL8xSxQxUdsdELsht6WLh3buTunlIO36Ubo980hXyf6oxsfvMrDsn1eve28cpks | |
| 19 | SXZxLpfQm96753mWICz1WJcoUv1EXpFKuqxb3OJXu6di11NQEtFNd9rM4x7MJQja | |
| 20 | ICr5WXxzX0ObEUxY6xTjMlUyHkmR9ekEEPZUdrwpRFC847bV35vdCtMRztghecBH | |
| 21 | tHMhTEbuYxpjBZ0hqIkLzDAiWenqca2P9YD2sgntTJFfZ3V/oi/REFxj5v5BmNQ2 | |
| 22 | wCyppoWDyD+oWJyh5dwuOc+xlYboN5EtIkuhS7/ZuvQipZpeJD7w4pkPO7l2Twal | |
| 23 | aHulJJV5f40gpIniullTC/I6P9HIp94wZ+UPm3/9M4AiO0oB0x4uk+buA7nCZ5Oi | |
| 24 | BaZKwO8nMFQBEaNuqKz+xLeokum3Alcwx3drwi0TlBX+GafrFFHwhdwDGuQsWpGT | |
| 25 | vNl6LEBNduPvs57382W13aiYT/p470M/RuTt6qpLyLVsWmGO5oh8mm/WWGDzza6Q | |
| 26 | 2NuUBcs2ZCECvRlEt//689elx7VDbJwE6Mw3V8bosGx8y4XcQYATFqxm7WflbBpo | |
| 27 | 5HR9AST2Noc6g4VPepZSgi0T4lRbIsyLml7kIvOQBre4i36br0VLIUairez1mqpm | |
| 28 | sG3P11076R+g/BcL4hg9jXE= | |
| 29 | =ONEK | |
| 30 | -----END PGP PUBLIC KEY BLOCK----- | |
| 31 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 32 | Version: GnuPG v2 | |
| 33 | ||
| 34 | mQINBFZZS3oBEACbRmmzVwF/Zf/zGEZTGXWzeCjwmYcvCx/aqklIWRFC/PPRwZ53 | |
| 35 | rNgeVpEHNu31duF3JCEX/7fL9rmjnW0C2mQCzkvKF+rZNO+jPL/0/fsjVfnSXx+g | |
| 36 | m9yVyPmR0XvR0Kk5PqjR8XH/syNblnCo16fr7YK/JMrGM9E/d+UomomXKALbgebX | |
| 37 | oO0c8eA2Vij4b2BAFr+L54MTzquKqyEru9Ty2PTcIBxcEYqko8i3Ttej6WVMKphW | |
| 38 | J9QNaeVF9mfHuA7zpFlwtfFOrUnA2Qh6IwT+w7o941q4TpzYNVlcR3IV2P51CZrG | |
| 39 | zQAGRvWWmg5yswhyTEJpt0i4eLoqeJrcNZRT8FQjmcXgtdPvSFkJPi39e5LrT23M | |
| 40 | /W5tHvnldFDd4RYQmoO3XcIJzyEe6yXNrcaTT386m2e+cjA0SwZ7l6kHVhMikaS3 | |
| 41 | FWccQ9VgWqLHZPd0f9oKdXbMMoIZs0D3F4hoz4oE6xkntEhw3Z3cVrKGpYuhJOKQ | |
| 42 | yPoCaNEpnT9qaTU8BmG/ToUWXZDuhm3FOAOEOOtFFChfy/0+9HnS6Q2aogYuD++o | |
| 43 | 6XNSFCwONIRnoHyIRjCA8ce/GNsxpBp7bjUDGLoQJzmki4O/lyxMxS5k0Z4mjLS+ | |
| 44 | xZo6OLt8LW5/w3YJUEU6PM88GhA1c3dm+U4mV3oW0QL0WG0b1tSxhLHf+wARAQAB | |
| 45 | tD5Td2lmdCAyLjIgUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 46 | Y3R1cmVAc3dpZnQub3JnPokCPQQTAQoAJwUCVllLegIbAwUJA8JnAAULCQgHAwUV | |
| 47 | CgkICwUWAgMBAAIeAQIXgAAKCRCfWX9NIaVtX/L3D/9NJVFh9tBYgzwtbhgHTVxq | |
| 48 | U3VKeKUIvvWxETtaYmKsL8BPBwVM2IHDPyiOGczxe7RbpNszoIY/EBKNsI7yOnon | |
| 49 | qrMebQVpzV0wK2WwfHKnXYXXFeWADapwBGEcST7WNwX+la/oJOQtBZpMbBHDia4C | |
| 50 | g7EENIdeWDRHxzl785PSlAOERvaKsPlFk3bolQl/Vhy5YZIe4Mt9KN5LZ2E+xz3Q | |
| 51 | DDplOTi3I2df9Maf9UOxrS7zk2NvHw+5YeqNs7cqp++mjIRQ7/M+PGPx7PZMttBk | |
| 52 | Y7sIn1m3uSZkK2nEWZ91b3pZdr3Sff2Ig1H+ConUqy9w0CqGSqCmY/6QP05J4kpv | |
| 53 | ga1uNmKRJdv/pGHfTaoZ+dubm4+UzGpfzHdEhvmm4gC/+kU+nq5BuhvzO7iWKk0o | |
| 54 | kZOKT642WSsp7TYKp96sMh2xeUbYl/eAHi8nQfGuYeo6n1NaUMtwb8jYusTuISuW | |
| 55 | yWRSKaUanjjKGkl9LTpODWLkXHmqGJhp9l61AQ3fKDQgXuKuglWBfsZOhDRl+oYr | |
| 56 | Q22LzpSd4ISG/gXN3X4ADeuWJpe8d+nvpc6KtuShgRT+KeqrE9BcXfDdEk56I0Xx | |
| 57 | +eGb1v4f4nibyiCvw/mBDCRMIqOsc/jyqA9lydLMxv/Us7KNYqh/Dzx7obfRUE6L | |
| 58 | 2S6Hfx8PaYq16WXdxd/PBg== | |
| 59 | =5r2z | |
| 60 | -----END PGP PUBLIC KEY BLOCK----- | |
| 61 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 62 | Version: GnuPG v2 | |
| 63 | ||
| 64 | mQINBFdM2VsBEAC63xLZsLc7HBbJ1V7ak8dGNSDs2ibcaMKAuWU916UWjFX+KlZE | |
| 65 | 8ruOVTol1KvA0cac6CX+Fd5SMirpxAaEUbYMwVEMzxOG7NhBp0wAJiO3LWsVoL4z | |
| 66 | G7wIpdPzjxP32qUABpF0Z8uo5zhQL6uaWtmKIhlBlzUmhbxYFzGUuCO8Y94hCH5A | |
| 67 | 9l5Oedin3D3/v2T60/B2rygmQ1fC372Peg6m0dR8PCp42Jm+VXjgF4yfGyP4MJPO | |
| 68 | c1gq8AWNQ4Ex1qhQ9E/Mhbn88LvUQ+OO5u3iNw7AflBuvLaLy7VbD+pGpoGv3EdJ | |
| 69 | LsDJg3dU4F9Ii2hLAD5Sushtjx6DwwFJvKFsm7QzG7OTQB0rC9Gtw/MpopafFI0e | |
| 70 | Wo/6xmXnw9GQQ6uS8RoVri6Lfp4IpXdLZ3CMxBeJulmUpBdIFK+/SnyMfYW88tzx | |
| 71 | DbEFpXa6SaksSXjAXuXhUu+h37YdIfWcbE0KUXH848RcRPnTUOBwsqE2UzLQjF3A | |
| 72 | aPV7YIQxNNp0mUsRE+9R6yGhSog77jsu5XusswYEOfSU9p/bkQd5kJ5acTyHDU8A | |
| 73 | +q/+O2T6aZqIFOhgXFiRj2TDGlqj4K+LUycpMWzPgn+KWKNnWgbJH1u3xXPnOZjT | |
| 74 | 0i1Vm2umWd7OxzThSvlPGlvRLwPKWhdeFL37M3Bg3og1P5TgP7j4HT6Q2QARAQAB | |
| 75 | tD5Td2lmdCAzLnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 76 | Y3R1cmVAc3dpZnQub3JnPokCPQQTAQoAJwUCV0zZWwIbAwUJA8JnAAULCQgHAwUV | |
| 77 | CgkICwUWAgMBAAIeAQIXgAAKCRBjvBz+kdMGxjBhD/9RUFlNP0cG6RJPl51mPCtO | |
| 78 | YMW/y5ssYyWi6u8q44Ccqit4EKjXUaeha4KSWQS9c+7q8bbfxbtl6AEsI+fxx3RA | |
| 79 | mYMjXfPnpjxqJLvwXOzAmG8bZzycdKiC1XBINR3e/Jw4Zu/yj/GtWSG2+OogFfNH | |
| 80 | n5Gg43B8D/fdqQkvlFXVuM0kMKPmAc+S1ikBvprpyjya47EKx5rWSf7pl/gm4jBE | |
| 81 | dBrWdpaBicOQmuv+Vr59rj2/UCWdD/dZRtwB66qn/AIZIgEOLyW2s/Mu9VK5zoNs | |
| 82 | oUZhRpe9t3eH59KbKvU+JdADMhBnUe3r4/HkSbHmPoML56g8RQV4T3LZa2sMt9Z3 | |
| 83 | UC7WFr3VfPxXHpI9BhY8HJvaB4ML6PvYuXHP7TYkrSQ9FMoxjHcwEE7cga8BzAHu | |
| 84 | MxCuGrPryHRyApdFOh6oTts8/bjn+sb0VVvnAjFsAjDcBF18s5aI58eGLzLBgRnZ | |
| 85 | jyGvZ20h+I0JE3vDydi3rVEBm/fgkUwTtBuEG/mIwIea9QEcMkv5dq1aYheav1NZ | |
| 86 | Amqr2BsSl8PufUdfGgMKjMIR6Sv40mhTCUFSL1TG8OsaOecK7XXEjcpaQjCg1lqj | |
| 87 | hL04ayrZehJzuiP30htRdbrFraDr/WQOPW3VqE0DtjVfaH7AARKLp/HRDOd5hiUU | |
| 88 | RBrjB1unJxVpnKg4t0El0g== | |
| 89 | =ssEv | |
| 90 | -----END PGP PUBLIC KEY BLOCK----- | |
| 91 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 92 | Version: GnuPG v2 | |
| 93 | ||
| 94 | mQINBFlAigEBEACbGsfWe5nCOFrYSpz6oPh9ihq0RZQlktSz7E3Ou0cwSNqOnGRO | |
| 95 | s6z5pyPYlJgpvvaxsKcBS6R4DFq4/30Aut4Jj4T2qa0BXZqqrHrXyM8ucmpPpF0T | |
| 96 | jcRJAQZg/Rj8AhelYtcNKml/j8b9n8p14K+u+Zp0SudaNxLdxIbr94eEEDd/ecH/ | |
| 97 | caGspqPuJjBanQNTzV9ws8ft7NLCdWnSvh5aiZrsWIrFfFxQm8zh9kCim2e3QX+p | |
| 98 | wufMDIKH/uEaOlinVCmFJNXGqpeyRjrile+r6Bd8fJiFLFtUeIiCdyxD4nrV+iLx | |
| 99 | ZAc6boVeSXdawPpX/eyXeH7NhpEofFz02W1EAoNFKgzdoEi6CBaA9P9Jrk/wRZuH | |
| 100 | vR+Mzbuu5aXDwDCjhtFu2Mm3bmN5pt3xuYCYoCgOp1wEld+szMfSjQNNJfUkFwzU | |
| 101 | eaHuaofXHQxuQ/uIEh8cr8/GEYtqGOU82T1raj3Sv1GcUfj5RO9k2rI7hWro8Hzc | |
| 102 | oXjLTDfABSZJrsuDLrzMUDOSKb+R3rf7uDYf/bTWkpLwSvrJRQaMXkQm70WWBFF0 | |
| 103 | A75HxFBi8/9f35azYlFfCi0cEHAAHm0wdxU/D9b6TV/9zDedbgFl+/8xMBQiOX1r | |
| 104 | WfQrXA7zONhZpc+to5tyzrV57+Q4buKQUibyYut/7Gl1FbVaD4LvAUpbqwARAQAB | |
| 105 | tD5Td2lmdCA0LnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 106 | Y3R1cmVAc3dpZnQub3JnPokCPQQTAQoAJwUCWUCKAQIbAwUJA8JnAAULCQgHAwUV | |
| 107 | CgkICwUWAgMBAAIeAQIXgAAKCRDvVDDwceGyNQE4D/4jyvkwjMzp3KSZKTMvcalT | |
| 108 | JPmc4rkpqc1b3VJCTpG/QRK9faJAbUVBz+iJBRIA7OjsjW9nS+oEkschjs7mjdiA | |
| 109 | U3XxtJMsZSJiO6TRdstJg0i2jT1yhQ7zuf8xeFEpx0Ekya05mYHiz3LdS2TZJcZZ | |
| 110 | D713M1GFsb+bDRGk18nVvlUIDB+9jIoqLgXf3muzHUmF0VF1HHfjB5zHfd9h6P+n | |
| 111 | DG5e/qA1MA6jaoGcHK31qoqvrLvoDMYlo6Nirq5Gsjf8rNTwij2GM1tNP8BIn2Y2 | |
| 112 | 5rgQ+UbZ3dUE+2KgUg+cqNtZPe0szHOInUew/Kq4ogRWgSWw/NbR+W5J5Ro9pCFJ | |
| 113 | pJaLBhCDQ35CIfcp5Mn2qSr0UW+7U4wfsoI4Oui5/dRx4iXFLD2LRlQuLTe0vRDK | |
| 114 | N6PcSeybtCyxeXXopWZvdNvO9oMoJ6vrorZciF+tcG9qaqaaf/Y1h7pfwiYkLvwp | |
| 115 | 4RC/FFURZyjeyk8gfxaE1NfcnXM3rByW8br/gtL1VR/s3igKXk/rVeywlMeXyeXP | |
| 116 | CxS1uflC2dxGfzFiNFJoQlS+0XYV4nYNTVALe4/css3LLFtLt9rBKe3U7JmXl52k | |
| 117 | zyUq5nMsltYp3kg3dRYHejwzyrlVGt0Twos/Zqf8NztD9LPiVsZP/f84AobFsmkN | |
| 118 | ex1agHRY0JDH1IrwmfVwrw== | |
| 119 | =nP+X | |
| 120 | -----END PGP PUBLIC KEY BLOCK----- | |
| 121 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 122 | Version: GnuPG v2 | |
| 123 | ||
| 124 | mQINBFoBAhsBEACtaQbqQhwMedruhTrierPCHRy6ZmO4HuRdrd9LnOBSraQnHFb9 | |
| 125 | kc2IfuHwB6YytZg6VFy4iaFx6vOkZQk7bFiAMB5RwIdPm7OmHGAYWkKeDOCB3lJB | |
| 126 | gJ0YdP7bMOGJL21RRZfUmkTMaT4zP3J0NeUL/mt4ezdJQyyWxdYigN2AgglAxZve | |
| 127 | 27K+IjlQVvuAe5MWqPn4pTktjWxuDkIN2BvdWXz5Ycbewul7Hi9dZzaLIVDeTq2F | |
| 128 | MUjR9FBJoNpJKjPTAeOyXj2jvHR753yAeRG/79sfeId9568XNxTi/2OXqdkvwg/q | |
| 129 | huGbx0fgkqnkMw/0nvqDVsbnHXMdE0WNVluemt6I9hJvoHfOEBYYAZi4+spoVCJW | |
| 130 | xwwgVt8tNTgbynejzr09d1RgVJH/OKcKCCOTtbbjUdtMt3MMbaBaN10AKKFWWBbR | |
| 131 | Tom8J6wwM8LsKkFj0F5uzkG928C/vx5hFv3ZltlFUu9j8u4WU2kF1D1nzhw4E9+S | |
| 132 | epq4jrWMa5Dvr9UhnkJCW0g/0vPnynbOcJaXyWQtqxdgAT9LxMBeMSd26O9UklaH | |
| 133 | INivaw8l2SpdauJrYon0uhK8RTTp2rSt+SLHqgxsbmGmr5jTm1Z37EzffgoIFDOB | |
| 134 | a+3zHaLJvkeZQXzbLAqzfHYSV9lUe7In+F9tqZ5l7702UqJmIWoGb6IGqwARAQAB | |
| 135 | tD9Td2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzIgPHN3aWZ0LWluZnJhc3Ry | |
| 136 | dWN0dXJlQHN3aWZ0Lm9yZz6JAj0EEwEKACcFAloBAhsCGwMFCQPCZwAFCwkIBwMF | |
| 137 | FQoJCAsFFgIDAQACHgECF4AACgkQdjjx+ysrCMSihxAApw7qKGfiN8a4bFVwKRdY | |
| 138 | 7BLYu9HLetKHUJPerypKEKfUshU0X8Ns3lBxjSqNY2TvLyun1kbtUsxy+qi/X+HM | |
| 139 | nb93ONYOAeny1DFxUdiehhVttTQQB3RXdmhHGytoxzHX62N/uo9tYW9xQ+gaK+QC | |
| 140 | Rt6nZN0Prm6X+4vpQGD7H7O9cN8pw4YuoJRDwn6bFPl7WgqrYWX8/jvbXH1NjbJi | |
| 141 | j6kXvDSzwtPQNsj7vTC5K4TBMgfBFw5kndu+1sEHAfPIbwK8w/EGr32eSRT6l3xk | |
| 142 | TYFquL0S5NGCi9/pIqT90knsDqXyNer4xmwQ5FJPUTpdUbFz0o/DQvIFrbJ465Q4 | |
| 143 | feibfhpxVqLCpX8goosAS5nd0jRGicSYmoxdtUBUp4gn3ee3yI6JbA0TN8haczNC | |
| 144 | e0FfQD9s9O+m6ft2/CzIx7YFeiIRhfcjfmGJ0+eAdpEsDqC5Hyc60hwHhPg222Ah | |
| 145 | ASkhwDD9NejskxvdMUPALk2C41ZlR1dYqfXwUJJDPwNY210QQgBZ0+GG72ErYssh | |
| 146 | 4sG5U9XRv4IZhFlgBVmMlfbSi71BawOy+IN7ii49m9AY7p6U+m7yoeZV2H8YJbTk | |
| 147 | KhfnS3rZqsSU+ZYJYkGOxnQetkKUDGaVKdwJE49ll5R1/4om0h8aOOU8VyzrXPc9 | |
| 148 | cZMQ1BcfMNkeu81HaxE0Lpc= | |
| 149 | =l0K5 | |
| 150 | -----END PGP PUBLIC KEY BLOCK----- | |
| 151 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 152 | Version: GnuPG v2 | |
| 153 | ||
| 154 | mQINBFyUJhwBEADDBN6jVDScsgzfQDxSQga0Og4O3N/nIquwi/DGOgsAsTMWcVA1 | |
| 155 | gmRJb792vWa9CmnHILl3ap8zObDSbcXg90nx+eCzWJjG+Ud5c7xuam96NR8ntKmU | |
| 156 | 8+BbH/dp8zc9WJB37TiWcaLsddrn58zfm7Ml6P9M48WAeRJX8nxVBTw1SjXJurW0 | |
| 157 | Ab8LOgfb60I09Skq72Ud7HaYJOG03iNTf6qLlF977OQsHCb21BnKSAmJqapUS96/ | |
| 158 | VOngz7TBzYz4rntfetb8hg28WtUl1s5BQzWaFunkP03b8mPh3PL1SZxutwViVWBu | |
| 159 | hf9kJtx/MLb79fnuJEOus1FvDqJdpd83H+XmXMIDYWgcBIBVrLT5HDtRerjF178H | |
| 160 | okb1F+gboGIqhnx25xTPIYctSHPgJRScZp4WKrqQLKswAmSL4YJXnkXSff05l4gE | |
| 161 | WXQpEMLBZa46qmu8lj8HfoZSbP9lfvEtZ6A+Q3sfh3gjYPv7e6n37x22tSgvyzCb | |
| 162 | jHU1pA2rv10AHK7EIeEQElN+zCyAbmKuhPBiCyxDFg5Dx3xNkYwg9szBJ0KleVD4 | |
| 163 | +Y3PZJ4N+u+SSATYnHGtmzvkhiNtqJCCwuaqY+jjVObzzqvLLtGjtjxNUWi2X4He | |
| 164 | q+r2fubjCOW14UnQ06qfr3mVUSmuLSKs8BD8qTGuqlgcenGsY0bk0qUPcwARAQAB | |
| 165 | tD5Td2lmdCA1LnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 166 | Y3R1cmVAc3dpZnQub3JnPokCPQQTAQoAJwUCXJQmHAIbAwUJA8JnAAULCQgHAwUV | |
| 167 | CgkICwUWAgMBAAIeAQIXgAAKCRCSXMHM7T0VYSm3EACUtuxMfTmGexA2xBvGhKQ+ | |
| 168 | bi3kRMBj+9BoSkVV11gDvumurldXRoKsIIxEdrD4xjagSNiVd7zj3L9wANu6+YgP | |
| 169 | HgBq8sUMXwsyXdL16jNC28qVqKF4jZxwmI9t6nVpQOSxGfBxdXmIhTxDDXFo4JMT | |
| 170 | uKx67BaP1GzZ+BKvxm09xChIJ5xh7x8/bsZ7HlXqc++ARn0Lh9d5CISUKE1PPnMN | |
| 171 | KyRUNt4X/qj7zJHDoAihufPKodvvXPsVAIpfCJZm7XB5WvP63IvQaFW/cX5wineR | |
| 172 | FZY/BKS+tsJt45jJ9c/Ofzqrr//stCz4a44fYvpqaxIqTLr4CpNH3WBIM0RBQqJj | |
| 173 | 35jJvdrNIuueby7GN3afRcvZIQBkbMkwZrW1iT8eah3EQDiXszbi7GkbXuOxQOn/ | |
| 174 | n8KJJvTJU7wAyH4WLvvWLFUm0oyHjIW4K9vSUM+x74WRuKxVikM6FAJ7uXsYtZ3Z | |
| 175 | lgL2hNlbMwpB+wxvA9isT3dSyzAtZmXpomOLuQTETtm4tSpt8XnF3eCsAKHSWqrA | |
| 176 | /zknqizKeBTPprqibixfO3dwUzFhUu3tkhxznIN3eEUrDMPxNrxObqJf1I4ySUYe | |
| 177 | vc6fqBG86SJ2yjN3IMJm5Y/z58QQUmSOweL9xQSr1hdcCxBtmLSjAlVzJMkpQ/TW | |
| 178 | xXPfHp4mZnRMLsGyO3eYrA== | |
| 179 | =l2j3 | |
| 180 | -----END PGP PUBLIC KEY BLOCK----- | |
| 181 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 182 | Version: GnuPG v2 | |
| 183 | ||
| 184 | mQINBF3DedcBEADmr11PU7BBVSEjSx3z2bqrktMURD2AnrXJgL+sAeZfMaZpDZCU | |
| 185 | pmLKtI32Yp5X3Mv3mlj2Mz3VdtRh7ni83E5cqTLXs4Yjsujgu6nWS5qWqmSYw0Ax | |
| 186 | RszPPJISf2MAbZyBQJpaoDK9t2eIh3yG6J9XhIMu/ZpDND8afNYGNRhXKetv6+l7 | |
| 187 | MHTYd5rlU94eIXcxLA/yV340BVTMoaiIfAwUF2uFubDYfro4Ckj+xzjGIvn3ueu0 | |
| 188 | u+Yfmc40YIuCsA+zgf24Tie/rIwifEzWxFCka2jNPU+q8XIrbPmTKGvxnpwjBKIz | |
| 189 | B5HtB+yyV5mhnaVg1kkNZH/rZxJQm/FdFS9IXmOmV5CFn+R8grTxsYP/A4jDHnmz | |
| 190 | wx/gJuUvt/ADt3cuU7sGLtT1cvH1UlS/fso2bDDHBhuEa/9hjD0uIYpLuR4eTUQs | |
| 191 | WNU9a2WFxprNfM7nbUIWqfTr6tdnQORPnDi8lSGePlJNWQHzg36WyxPzq9EG0S5r | |
| 192 | 35Gb5NXeok6CN9x0EUiRt/Fl0POQRJ2Y6TWmOzaZ+8B8HExhA02d86Wnzfss8kAB | |
| 193 | eLSHE6aOguwujep9LFrTxUeMZTIkk/kxc0ibHuq0r1jwRWnCx9TwXCFeAW1gs7eo | |
| 194 | xybF/HVuDqSLaRIgpIl2KFxvXRY6g37ggtcAxV5DlH6oK90ja+72Wre8+wARAQAB | |
| 195 | tD9Td2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzMgPHN3aWZ0LWluZnJhc3Ry | |
| 196 | dWN0dXJlQHN3aWZ0Lm9yZz6JAj0EEwEKACcFAl3DedcCGwMFCQPCZwAFCwkIBwMF | |
| 197 | FQoJCAsFFgIDAQACHgECF4AACgkQ+vaYnhvBb+oGHQ//ViB09Rk7W4BxyuvwDZx8 | |
| 198 | w7JR/WfCFDYAz210EILu2o3tqHWpfShynA2V/oOFT+VHykr2TK7wT2n/o9axfIq6 | |
| 199 | rF8W+X2VnXzwzN3a04iVtakcSeCuH4KIiT7vIjfOtmEwqJlpAIe6LF0NXb5wV9/I | |
| 200 | mxc7xLKbTCBSjrNqQsCOZ6VbLqwQuOjI0afRjnUsI07u/8bo/8WeZS1roKy0ntVI | |
| 201 | wyw05P5cV64pjHwNXH5CN8nB/G4pjCRwehI+4hAm0SOUfIDyLdQ4IThAJY+FVzIQ | |
| 202 | dXSKMyVNQMe/PuwLB3CBNMPOtxsEwOdgrLwClm2jOOS/bjrBI5jerUgCSBDPerEP | |
| 203 | 3rb6hjehuvhYudYZ+awmWG2NRxdWqUBO3twudVci4keQjjaBM+XiaWpEn9jD3XkI | |
| 204 | ZZC++bXx0o6ugDGFNTNwpFZ9hCC0x8djDrJDz1OdSYA4Mn4bB1n/8FI3+wSk8AP2 | |
| 205 | YzfjXbdXQMe44FUWPJgcCJ8EEsF9eKtw5019288ECIlfaHIzw+tgeg7iTShhB7wi | |
| 206 | 8T6PFJvRp8L4hssDfzMS9ZG93InUGL+6eyasIVXJtPDmCCP4LHMN3XYH0TgqBriD | |
| 207 | A6MXJzpykPpl51JkXNRtCWtUVBJpDN3L6Ue4Ouxqs0amMBJCNXM/6t+aJfrgwqiq | |
| 208 | bDzlXsGoKE1i/038Ag41vE0= | |
| 209 | =kzvP | |
| 210 | -----END PGP PUBLIC KEY BLOCK----- | |
| 211 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 212 | Version: GnuPG v2 | |
| 213 | ||
| 214 | mQINBFyUJhwBEADDBN6jVDScsgzfQDxSQga0Og4O3N/nIquwi/DGOgsAsTMWcVA1 | |
| 215 | gmRJb792vWa9CmnHILl3ap8zObDSbcXg90nx+eCzWJjG+Ud5c7xuam96NR8ntKmU | |
| 216 | 8+BbH/dp8zc9WJB37TiWcaLsddrn58zfm7Ml6P9M48WAeRJX8nxVBTw1SjXJurW0 | |
| 217 | Ab8LOgfb60I09Skq72Ud7HaYJOG03iNTf6qLlF977OQsHCb21BnKSAmJqapUS96/ | |
| 218 | VOngz7TBzYz4rntfetb8hg28WtUl1s5BQzWaFunkP03b8mPh3PL1SZxutwViVWBu | |
| 219 | hf9kJtx/MLb79fnuJEOus1FvDqJdpd83H+XmXMIDYWgcBIBVrLT5HDtRerjF178H | |
| 220 | okb1F+gboGIqhnx25xTPIYctSHPgJRScZp4WKrqQLKswAmSL4YJXnkXSff05l4gE | |
| 221 | WXQpEMLBZa46qmu8lj8HfoZSbP9lfvEtZ6A+Q3sfh3gjYPv7e6n37x22tSgvyzCb | |
| 222 | jHU1pA2rv10AHK7EIeEQElN+zCyAbmKuhPBiCyxDFg5Dx3xNkYwg9szBJ0KleVD4 | |
| 223 | +Y3PZJ4N+u+SSATYnHGtmzvkhiNtqJCCwuaqY+jjVObzzqvLLtGjtjxNUWi2X4He | |
| 224 | q+r2fubjCOW14UnQ06qfr3mVUSmuLSKs8BD8qTGuqlgcenGsY0bk0qUPcwARAQAB | |
| 225 | tD5Td2lmdCA1LnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 226 | Y3R1cmVAc3dpZnQub3JnPokCPQQTAQoAJwIbAwULCQgHAwUVCgkICwUWAgMBAAIe | |
| 227 | AQIXgAUCYFlw2wUJB4exvwAKCRCSXMHM7T0VYcDjD/9gX5EXlPJU1QgFw4PwRUDj | |
| 228 | 9GxJ7DQ8ocgZT3mtt03gpRj7yTOL0iBDsJ4GtDiPcq6xCm7WEmNYBs/cJWVGwBC2 | |
| 229 | jeQCUCkxCXR310V3/RRFMhKZZPBq9A1UqqooO0WYkpR6JFP2a5cf2kounuyBoVGX | |
| 230 | wV7Cn4ZqX/fLOt156EiWUtOxC5L/nJqn6Ea57arwVUwZ3Q2tcKthxFrmMD9H13oW | |
| 231 | Y4coWiQhVx0xCMbc4cPh7TeRIdUu7D2JJPg/ypqhE2fIPPYrCAJSWp9A/m5oaLM+ | |
| 232 | 6/ABV+JYw3sgmnCSMxX+EV5iDsRamWMJwO4Yep8qMBD61jID5zn0N+VSLdEVfX+5 | |
| 233 | O4tdHMvC/YenJ0SFlWmZ7VGD99497IlsTMBFuOzBwXsfwdbSmG5KB6uKormLB6KB | |
| 234 | INvASgi7HbcYgM6vh82mvpswp5UmrT8f2trnSaxHUz5gtUiYFKdBrLgbLBhMlUTZ | |
| 235 | giRHJqm7DnYJVUAOOj26uu06gcXu77MzEiBT3PGVNPMgfYhc5I6hnx4nrXDYT5IT | |
| 236 | bP9Gt1BpsaG8J2jZL2OyOdkd7FkAuWzJVmozDIhMcsf5AjxrZaSYKc2BwgevdIB/ | |
| 237 | nvrD/IHRzS34EDnqv2J2LsQqWI3PM7JC5fW9L69NaSWdWpIoHl4gPcm55wbF+tHP | |
| 238 | SnioHPOvgHUi1wc55I6QNA== | |
| 239 | =z7kI | |
| 240 | -----END PGP PUBLIC KEY BLOCK----- | |
| 241 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 242 | Version: GnuPG v2 | |
| 243 | ||
| 244 | mQINBGGJWe0BEADGVbVhCEWnCMdAoxCaUaCPNomG5wdzw+sgx8FvqCFiGqYq/qzN | |
| 245 | ckaydk+XWfiDT/Vo/NjMYnUJ0+gdSua1X0IUGqQlATYhKSGTHqgab4nwDCym0nFl | |
| 246 | SBHPDgmMTNO57dHSGYduPjuisuhq7i0pybyn/oXuHAW5SIlz7bfpaz2jzFDY4xEP | |
| 247 | TXImllHOmTxBsDdwv2J+H158w1NSHJoHeXpPIse3VHlcwJVNeGYMiDx4Qw9TfaL5 | |
| 248 | fI7GgjbcELCXw/pGjbiz/JFX7Fzm4snesnqwIG3TN4kH3BdKRNMFnyN3zNZxQTaZ | |
| 249 | LNCr3NCzhmmWTjeX5VSu6C+W8wuYRAThqJ42HpPR78zgv6pMnHgdhqquqAfL/Oid | |
| 250 | XlISbQ4bSdc1y8xkLb86pzwzrLV3LmHjJ3NAi9U1QXygW0ikTgbB9LPzaTSGVU+y | |
| 251 | 0PMQ6JrRfSvyt5G7RmVzqm1ro8fkmeZBjNUf7GXCldn9linbhKzh/IvvPTYeNhIK | |
| 252 | T99giWSChvZyR950vE5a4WEYKV3taJRLCqXHH1d7FKC080pvPR9VsqWB/thQ48Vr | |
| 253 | dPleEa6O9IFMDudpOfsXTnHtnO7wKssN9RtxpotRukIhLGWxjHED3Rrt93T+IMQz | |
| 254 | kpKz+Tcz/koM8SuAcYX15N/jeW8BzgA6Y6ODI/OSAMBzMQUYME5S7F7xOwARAQAB | |
| 255 | tEZTd2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzQgPHN3aWZ0LWluZnJhc3Ry | |
| 256 | dWN0dXJlQGZvcnVtcy5zd2lmdC5vcmc+iQI9BBMBCgAnBQJhiVntAhsDBQkDwmcA | |
| 257 | BQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEPFn3xrPnOBpZQQP/31gfgRaSdBM | |
| 258 | Y0ob4SX+WgcPO9Ks7LVHAojH/jDdra6EjCdM60YH3VnSEogt3oRSx7TyZhQxy6E8 | |
| 259 | cD6j1pJwDIo7sSdsOnFfFQSCRVYITTGd6CfDDlVzw45qVQTD/kEXM5GLCjCERuwL | |
| 260 | bFa3Idjy/YleAizAqJhj/05WGQuKBVYLifvoSkOLEfUyrEyAUjmPM8fyWSb81ujV | |
| 261 | 5BxMONy3ahN4zb7Gp0KktJQZmkCrs6Y8HzzUTtB0P72MewyYUmoQkoj+DcujuvfB | |
| 262 | xeOUgTZzmgRQA5bBBjW+WgcjvDamS6/DTTvrQo5K1zSP53vm/LZXwB2V9gJL6ytq | |
| 263 | njwJwnZxC13iyqoMDTgO7OAd60yXUhQDJqARj4pjAlfuZhO2ITnVKfTqXpRPSXOO | |
| 264 | rvsTqCfg2sTvl8hytrqxzEW0LEU9tYPbfw0gZ0CG874jAtpvhMf0Iuz6feXDBgZS | |
| 265 | sT9UHW6sp11oefDbxiaMkdqsRLzrQDGM7ghpUGk1FtduxobC8edfMsUkiKNTBcDw | |
| 266 | wdgPP+YBRxMYfhsEmuiHlqW9vY3ytuhm+GRVvI+Rkd2XjoDcYCUX/RF2JSr181j3 | |
| 267 | qJ5VoE//0imfk4FdhL2CYY+bww+1BiEvUnb2JInaaaT4oDvjOF6SDPqziDMuLSEc | |
| 268 | l1Y4x1Ig0njPuZ23erJGFRgt2R42gBy6 | |
| 269 | =kqeX | |
| 270 | -----END PGP PUBLIC KEY BLOCK----- | |
| 271 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 272 | Version: GnuPG v2 | |
| 273 | ||
| 274 | mQINBFyUJhwBEADDBN6jVDScsgzfQDxSQga0Og4O3N/nIquwi/DGOgsAsTMWcVA1 | |
| 275 | gmRJb792vWa9CmnHILl3ap8zObDSbcXg90nx+eCzWJjG+Ud5c7xuam96NR8ntKmU | |
| 276 | 8+BbH/dp8zc9WJB37TiWcaLsddrn58zfm7Ml6P9M48WAeRJX8nxVBTw1SjXJurW0 | |
| 277 | Ab8LOgfb60I09Skq72Ud7HaYJOG03iNTf6qLlF977OQsHCb21BnKSAmJqapUS96/ | |
| 278 | VOngz7TBzYz4rntfetb8hg28WtUl1s5BQzWaFunkP03b8mPh3PL1SZxutwViVWBu | |
| 279 | hf9kJtx/MLb79fnuJEOus1FvDqJdpd83H+XmXMIDYWgcBIBVrLT5HDtRerjF178H | |
| 280 | okb1F+gboGIqhnx25xTPIYctSHPgJRScZp4WKrqQLKswAmSL4YJXnkXSff05l4gE | |
| 281 | WXQpEMLBZa46qmu8lj8HfoZSbP9lfvEtZ6A+Q3sfh3gjYPv7e6n37x22tSgvyzCb | |
| 282 | jHU1pA2rv10AHK7EIeEQElN+zCyAbmKuhPBiCyxDFg5Dx3xNkYwg9szBJ0KleVD4 | |
| 283 | +Y3PZJ4N+u+SSATYnHGtmzvkhiNtqJCCwuaqY+jjVObzzqvLLtGjtjxNUWi2X4He | |
| 284 | q+r2fubjCOW14UnQ06qfr3mVUSmuLSKs8BD8qTGuqlgcenGsY0bk0qUPcwARAQAB | |
| 285 | tD5Td2lmdCA1LnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 286 | Y3R1cmVAc3dpZnQub3JnPokCPAQTAQoAJwIbAwULCQgHAwUVCgkICwUWAgMBAAIe | |
| 287 | AQIXgAUCZBiLlAUJC0bMeAAKCRCSXMHM7T0VYSogD/i38g/nf1JSDrWMWVKLzTWA | |
| 288 | MO9V9JR1wcxx3YNQmGPzUv+gdXgOv8kWSKSJ5zopTrWJg/AJ6etShX7HpjXeHULp | |
| 289 | aJGLohlMQuPCqD2+HvxpY67iA9i49owkzQI4gSIC6UwtCluWQCgcz2qE5zBWB1nK | |
| 290 | ImegSYn9mHIooJ9em4UwHdEDztWPYeB192M+Eq1+HK3BlEFDrMxWdzVuEQ+oGslm | |
| 291 | 4Z5apV+r65fQa9T4rRxOpau8T9tKpXfaw+IzUDUE4PRTOyOkR8AOFm9hIg5KlV9z | |
| 292 | 1bhDRS4Xpb6i3H91OyGROoB6QsTCmVGnSw35bzYjlOc5I1bAtqJu3EC30gV97kCj | |
| 293 | btm/cQLb+su/DEwjp4/lRtQagmRmHUuvJyPA+WNNiPYY/Ldzfy3w/SK4eJqM3Ctv | |
| 294 | iEs+btFLg4yXCBmL6UFZ4rmZ++x11DoW9l63b/9PJYPASXBGXamqsrMvX+IozjQ1 | |
| 295 | CzlI8Pi5XwZfa/yAMiNXTveKItZJFUl4L4xMz2Fk6q8vByb5P2TziooTNtpjJedg | |
| 296 | +W2ZNKatqZtvqowJlr9utWmogInrlv+YSLXN43kVt/X+Dbi1qzIE0FnApLPJEw+x | |
| 297 | nuahcoGN56UfxsdlmMDQ1QWs0Zp1DzXGOwAo9ciEIxrqlxR7N8rMluDv9vltVnZZ | |
| 298 | 1p6hhnwu6nXqf83I5GJK | |
| 299 | =77jt | |
| 300 | -----END PGP PUBLIC KEY BLOCK----- | |
| 301 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 302 | Version: GnuPG v2 | |
| 303 | ||
| 304 | mQINBGGJWe0BEADGVbVhCEWnCMdAoxCaUaCPNomG5wdzw+sgx8FvqCFiGqYq/qzN | |
| 305 | ckaydk+XWfiDT/Vo/NjMYnUJ0+gdSua1X0IUGqQlATYhKSGTHqgab4nwDCym0nFl | |
| 306 | SBHPDgmMTNO57dHSGYduPjuisuhq7i0pybyn/oXuHAW5SIlz7bfpaz2jzFDY4xEP | |
| 307 | TXImllHOmTxBsDdwv2J+H158w1NSHJoHeXpPIse3VHlcwJVNeGYMiDx4Qw9TfaL5 | |
| 308 | fI7GgjbcELCXw/pGjbiz/JFX7Fzm4snesnqwIG3TN4kH3BdKRNMFnyN3zNZxQTaZ | |
| 309 | LNCr3NCzhmmWTjeX5VSu6C+W8wuYRAThqJ42HpPR78zgv6pMnHgdhqquqAfL/Oid | |
| 310 | XlISbQ4bSdc1y8xkLb86pzwzrLV3LmHjJ3NAi9U1QXygW0ikTgbB9LPzaTSGVU+y | |
| 311 | 0PMQ6JrRfSvyt5G7RmVzqm1ro8fkmeZBjNUf7GXCldn9linbhKzh/IvvPTYeNhIK | |
| 312 | T99giWSChvZyR950vE5a4WEYKV3taJRLCqXHH1d7FKC080pvPR9VsqWB/thQ48Vr | |
| 313 | dPleEa6O9IFMDudpOfsXTnHtnO7wKssN9RtxpotRukIhLGWxjHED3Rrt93T+IMQz | |
| 314 | kpKz+Tcz/koM8SuAcYX15N/jeW8BzgA6Y6ODI/OSAMBzMQUYME5S7F7xOwARAQAB | |
| 315 | tEZTd2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzQgPHN3aWZ0LWluZnJhc3Ry | |
| 316 | dWN0dXJlQGZvcnVtcy5zd2lmdC5vcmc+iQJUBBMBCgA+AhsDBQsJCAcDBRUKCQgL | |
| 317 | BRYCAwEAAh4BAheAFiEE6BPIkoIKb6E3VbJo8WffGs+c4GkFAmVN6ZMFCQeG9qYA | |
| 318 | CgkQ8WffGs+c4Glz3BAAl1MjB02h+TNnnmHg0RWSGUzIBpFEXQ8ojoQFhudloVlu | |
| 319 | 2zkdTzznXXpmuBH4QQTI0igPQyVQkOEXPAP05geeqOvlGm4wnwtw486Q5vTGxgn1 | |
| 320 | +WjS3OMHFFS4y0GiOciRtu6WhwFOv6c2eSLIOmoDDvsb4js+YqtZ3fFcim/6gmRX | |
| 321 | cKsEWzFyIcAxgm8iDks/sdqX2XQhkBuZ1bs3mOGGZnj8N2reNv0POJ/QTg9s5ydI | |
| 322 | 2NylO66kDmsNu7z5jkLg/Ol7eGuYvzwKIvdasHU2kd9gCPX/6B7mmUSK8LIiD9UN | |
| 323 | D6wetgkT/ov9XhYWWKZxYM2sPJVhVRLkMZkNjxSS7GRWeYgkfca+xE2xm8KgbnpZ | |
| 324 | CC2F4b9g9tCLH5LW93SXL2pdurimE9pa26A0t8C7/CBwV2YkvUP3oBIVKH+vEB+m | |
| 325 | tS9H/VVaoflL/UPBPV7k1Nd8pgDxfUx+hDGW6wNrMyJSvykypWte5Xrk5q/TVTuZ | |
| 326 | wOZVyyH6mMxWPKyYiUU6rcFu9kMkRNodBB6E/IT/oQ2EFCBAbKAGeMWii4OJtwfu | |
| 327 | 3W1lC4GFNCE5Ae6V5ew++5GjN+5fVJnjyY0rbKvLPHa+y0Rkojw+w6avXKmCF4JR | |
| 328 | iPwYZF0RD0fuidRNNDG8HIZZq9fTuC2RWpdAk403/j9ary56FYxsYqyZ5saMn4w= | |
| 329 | =RrPQ | |
| 330 | -----END PGP PUBLIC KEY BLOCK----- | |
| 331 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 332 | Version: GnuPG v2 | |
| 333 | ||
| 334 | mQINBGbolYEBEADEvoijjZaq+5hLyiOHMns6+i/1mxczO5g9ZuXANYMI5uKXNgED | |
| 335 | dWoJRJV1DKwY+1f9oBdcEctD0um4LY6346p38SJOurk/zRqlEx25sAq0bbOn0epE | |
| 336 | BrOkHnmgBp+C5gWgrk+gKGjOXw63m2ipKp5joxP7QI7iplb7LRHnqOWqVFPF6c+A | |
| 337 | y5zq7/FFfECwHYdkS3IV8uYG0qPmKDYoJgqCbySGzbHTiawFt8OJS5xYqzhXrClh | |
| 338 | KMJf6orq8gNF4eBwa6FkyJFyPf/s8mbW3wREirL9DFinurMK68pUA7SDxLsegGgt | |
| 339 | 2PVse5o+1TVcKTDTCV0v5gmiQyXIUzvB87GaJLVIEIwYb08jtSBMvVLdVIpWv6RJ | |
| 340 | bi7za2LvfaCBcpSAbqCtoq/lk9NYrXs8uiENxW0srIWoKoe6Gfvz0XvJEjJPIMNH | |
| 341 | cy/42Nt3kgn6V3lHTioTPhxyEJ8AZ+s7yIeVR5fYuxdlVwe6zhiwvGtjWLmjTZBY | |
| 342 | RbXayDV3ekNL3rEQ4qhXrvcmW0/v7n+vzf6a7Wog6R4pHr67BafM3v9M6jpu4Lqk | |
| 343 | mLyXU/lX1+VTzKz7vDCz8CXafYUP8wFYGGW73xzd6Kho8vya1E4WNg+UPnYcu2SV | |
| 344 | TkQe50I2Ik95QEAEdG3DJrLiGuLwH170KgeMYpWffNLtUNH1oCkh1lj8jQARAQAB | |
| 345 | tEVTd2lmdCA2LnggUmVsZWFzZSBTaWduaW5nIEtleSA8c3dpZnQtaW5mcmFzdHJ1 | |
| 346 | Y3R1cmVAZm9ydW1zLnN3aWZ0Lm9yZz6JAj0EEwEKACcFAmbolYECGwMFCQPCZwAF | |
| 347 | CwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQ74CoZrR6mB/DIhAAnSHnGfRpr/0A | |
| 348 | 98dWa2uM2tt4oGT1+SN+va544/vu6CAc9jhvS871GvHe25B5HL5S6MDF3dim3oQe | |
| 349 | zIGaIx3DUhbb0/JLeayL3NfhbCed5DX0W1XIQtksjYuHnvBRD+zrhcTQKqumR+LU | |
| 350 | NVOh6l4o2Ko+aAYc8mIm+HufryRKJSWup1ZnExEdcZZEzyY4kT0H1fxAIWWU3NI1 | |
| 351 | LDtq1O0Wl5CTUHU7mI/h2eWrxFDg4SmfV9dv4uBXyvxherHEhImJXceQ4ZkxvYGF | |
| 352 | amXjlNzIr8c6y/IE8Q775nkfG5+4Gt+bGIJqxeSzfc4wq+txMa85TtRpgSthgqFi | |
| 353 | +yQx5qghs3y8Pqj3kDatJB41oQZ221WbBRc2uvFDMWUaOtJ/pRymCN54FUwxUm6U | |
| 354 | aM4VTWbGw0es1QRO+Px25Thoh8a5a3Fu0s9fa1sDJOUYSc7vfyRUfqNOVv5g8rnS | |
| 355 | sPTmOGGjrjxWHA0oL7B5hxCR+/jBhw+6mLu18qwGI7YpgyZYSzowPY+LrMm/J973 | |
| 356 | SyUtlCb2o42WhDR9FsX0AGvLhZpxy4Q7br7Pa2RXwmWEaxZik0iQ2Sg4pEvL5tVd | |
| 357 | aFIUvVsFlayfXSBCZVjH0uyh0Vkk1ERZpSmxkRWgzp5MRIfkP5eh9009uhEUmxHV | |
| 358 | Yih/un915S6ObH32x1IbJfi0cGK1NUA= | |
| 359 | =sWSN | |
| 360 | -----END PGP PUBLIC KEY BLOCK----- | |
| 361 | -----BEGIN PGP PUBLIC KEY BLOCK----- | |
| 362 | Version: GnuPG v2 | |
| 363 | ||
| 364 | mQINBGGJWe0BEADGVbVhCEWnCMdAoxCaUaCPNomG5wdzw+sgx8FvqCFiGqYq/qzN | |
| 365 | ckaydk+XWfiDT/Vo/NjMYnUJ0+gdSua1X0IUGqQlATYhKSGTHqgab4nwDCym0nFl | |
| 366 | SBHPDgmMTNO57dHSGYduPjuisuhq7i0pybyn/oXuHAW5SIlz7bfpaz2jzFDY4xEP | |
| 367 | TXImllHOmTxBsDdwv2J+H158w1NSHJoHeXpPIse3VHlcwJVNeGYMiDx4Qw9TfaL5 | |
| 368 | fI7GgjbcELCXw/pGjbiz/JFX7Fzm4snesnqwIG3TN4kH3BdKRNMFnyN3zNZxQTaZ | |
| 369 | LNCr3NCzhmmWTjeX5VSu6C+W8wuYRAThqJ42HpPR78zgv6pMnHgdhqquqAfL/Oid | |
| 370 | XlISbQ4bSdc1y8xkLb86pzwzrLV3LmHjJ3NAi9U1QXygW0ikTgbB9LPzaTSGVU+y | |
| 371 | 0PMQ6JrRfSvyt5G7RmVzqm1ro8fkmeZBjNUf7GXCldn9linbhKzh/IvvPTYeNhIK | |
| 372 | T99giWSChvZyR950vE5a4WEYKV3taJRLCqXHH1d7FKC080pvPR9VsqWB/thQ48Vr | |
| 373 | dPleEa6O9IFMDudpOfsXTnHtnO7wKssN9RtxpotRukIhLGWxjHED3Rrt93T+IMQz | |
| 374 | kpKz+Tcz/koM8SuAcYX15N/jeW8BzgA6Y6ODI/OSAMBzMQUYME5S7F7xOwARAQAB | |
| 375 | tEZTd2lmdCBBdXRvbWF0aWMgU2lnbmluZyBLZXkgIzQgPHN3aWZ0LWluZnJhc3Ry | |
| 376 | dWN0dXJlQGZvcnVtcy5zd2lmdC5vcmc+iQJUBBMBCgA+AhsDBQsJCAcDBRUKCQgL | |
| 377 | BRYCAwEAAh4BAheAFiEE6BPIkoIKb6E3VbJo8WffGs+c4GkFAmkXkkAFCQtQn1MA | |
| 378 | CgkQ8WffGs+c4GlQpw/+LUkquzG+3wt6WzHThd8m99PcVygHR4YnI/GTRYsno7l/ | |
| 379 | w4bB3WxhK8BFTr5GzsEDd2gPSIyKvqrcN1GP2lj96VyNfksh8LledNpzGz1HAgIt | |
| 380 | RY8NgzdQWqrOiyPK7T3cOkpOzwx4TNFTvEnKU/bPcdZM/muvLFManJr7bOvhuWGX | |
| 381 | KafvD6Q2EwofIIRaIocaVlsai1jJZcYCiB3UpTQL+pg1kdlYSVwnarEBvuAGEJan | |
| 382 | UlYuyS0hGFHpoU9VkxxTH0FzETN+03AtPXVaVJdjfmhrBUbWg7envpIUZ15z7PdD | |
| 383 | XgddnfoMIpfiVerr7DgbUdo3WervDtCo1PSMh8CeY14sdVsPlufCwP6zMLMllDBm | |
| 384 | VCEHN4vOCfabA/+GSev0Mtli60OUdFAVSKt0pGddONDWSrYezRD9lfofq5ZnRqFa | |
| 385 | 50K6IrWoczkv1Toh1NBh5V0bmnVx0gwa4rmNrrY1casCs4KprySkdKvOha7IFrf0 | |
| 386 | YHNUjRf1i0v8Ep2oE8nRgbVwbh0mxCyHchux7RIty85vyqQh/nff1ArChQxtrWsr | |
| 387 | Ok/0iS+TmMi+o/IxBR5KzaewYXHWKfuAYkGWPCbwxgc24Zd+hAHpnstZ33zcpL9K | |
| 388 | 1dQz0ClfOCKYQYZJ2MID1Ry27bPh5fJdWuGcXFlkhIebvXjllbD44yeIdCvc0rg= | |
| 389 | =12qA | |
| 390 | -----END PGP PUBLIC KEY BLOCK----- | |
.gitignore +1
| @@ -3,3 +3,4 @@ | ||
| 3 | 3 | DerivedData/ |
| 4 | 4 | .DS_Store |
| 5 | 5 | *.kc |
| 6 | .superpowers/ | |
.swift-format added +12
| @@ -0,0 +1,12 @@ | ||
| 1 | { | |
| 2 | "version": 1, | |
| 3 | "indentation": { "spaces": 4 }, | |
| 4 | "lineLength": 100, | |
| 5 | "maximumBlankLines": 1, | |
| 6 | "respectsExistingLineBreaks": true, | |
| 7 | "rules": { | |
| 8 | "AlwaysUseLowerCamelCase": true, | |
| 9 | "NeverForceUnwrap": false, | |
| 10 | "NeverUseImplicitlyUnwrappedOptionals": true | |
| 11 | } | |
| 12 | } | |
NOTICE added +5
| @@ -0,0 +1,5 @@ | ||
| 1 | The word list in Sources/KeycaskCore/Wordlist.swift is the EFF Long | |
| 2 | Wordlist by the Electronic Frontier Foundation, licensed under the | |
| 3 | Creative Commons Attribution 3.0 United States License. | |
| 4 | https://www.eff.org/dice | |
| 5 | https://creativecommons.org/licenses/by/3.0/us/ | |
Package.resolved added +33
| @@ -0,0 +1,33 @@ | ||
| 1 | { | |
| 2 | "originHash" : "f4830ec40bb4ed7681d28a845578098d2aaa25c4b7867710f01723e5ec0c9aa9", | |
| 3 | "pins" : [ | |
| 4 | { | |
| 5 | "identity" : "swift-argument-parser", | |
| 6 | "kind" : "remoteSourceControl", | |
| 7 | "location" : "https://github.com/apple/swift-argument-parser", | |
| 8 | "state" : { | |
| 9 | "revision" : "6a52f3251125d74daf04fcbd5e6f08a75d074382", | |
| 10 | "version" : "1.8.2" | |
| 11 | } | |
| 12 | }, | |
| 13 | { | |
| 14 | "identity" : "swift-asn1", | |
| 15 | "kind" : "remoteSourceControl", | |
| 16 | "location" : "https://github.com/apple/swift-asn1.git", | |
| 17 | "state" : { | |
| 18 | "revision" : "d9a5b37470adc940d22c3bcd5ca6953a516b727f", | |
| 19 | "version" : "1.7.2" | |
| 20 | } | |
| 21 | }, | |
| 22 | { | |
| 23 | "identity" : "swift-crypto", | |
| 24 | "kind" : "remoteSourceControl", | |
| 25 | "location" : "https://github.com/apple/swift-crypto", | |
| 26 | "state" : { | |
| 27 | "revision" : "95ba0316a9b733e92bb6b071255ff46263bbe7dc", | |
| 28 | "version" : "3.15.1" | |
| 29 | } | |
| 30 | } | |
| 31 | ], | |
| 32 | "version" : 3 | |
| 33 | } | |
Package.swift added +33
| @@ -0,0 +1,33 @@ | ||
| 1 | // swift-tools-version:6.4 | |
| 2 | import PackageDescription | |
| 3 | ||
| 4 | let package = Package( | |
| 5 | name: "keycask", | |
| 6 | platforms: [.macOS(.v14), .iOS(.v17)], | |
| 7 | products: [ | |
| 8 | .library(name: "KeycaskCore", targets: ["KeycaskCore"]), | |
| 9 | .executable(name: "keycask", targets: ["keycask"]), | |
| 10 | ], | |
| 11 | dependencies: [ | |
| 12 | .package(url: "https://github.com/apple/swift-crypto", from: "3.15.0"), | |
| 13 | .package(url: "https://github.com/apple/swift-argument-parser", from: "1.8.0"), | |
| 14 | ], | |
| 15 | targets: [ | |
| 16 | .target( | |
| 17 | name: "KeycaskCore", | |
| 18 | dependencies: [ | |
| 19 | .product(name: "Crypto", package: "swift-crypto"), | |
| 20 | .product(name: "_CryptoExtras", package: "swift-crypto"), | |
| 21 | ] | |
| 22 | ), | |
| 23 | .executableTarget( | |
| 24 | name: "keycask", | |
| 25 | dependencies: [ | |
| 26 | "KeycaskCore", | |
| 27 | .product(name: "ArgumentParser", package: "swift-argument-parser"), | |
| 28 | ] | |
| 29 | ), | |
| 30 | .testTarget(name: "KeycaskCoreTests", dependencies: ["KeycaskCore"]), | |
| 31 | .testTarget(name: "KeycaskCLITests", dependencies: ["keycask"]), | |
| 32 | ] | |
| 33 | ) | |
Sources/KeycaskCore/Entry.swift added +65
| @@ -0,0 +1,65 @@ | ||
| 1 | import Foundation | |
| 2 | ||
| 3 | public struct Entry: Codable, Equatable, Sendable { | |
| 4 | public let id: EntryID | |
| 5 | public var name: String | |
| 6 | public var username: String? | |
| 7 | public var password: String | |
| 8 | public var url: String? | |
| 9 | public var notes: String? | |
| 10 | public var tags: [String] | |
| 11 | public let created: Date | |
| 12 | public var updated: Date | |
| 13 | ||
| 14 | public init( | |
| 15 | id: EntryID = .random(), | |
| 16 | name: String, | |
| 17 | username: String? = nil, | |
| 18 | password: String, | |
| 19 | url: String? = nil, | |
| 20 | notes: String? = nil, | |
| 21 | tags: [String] = [], | |
| 22 | now: Date = .now | |
| 23 | ) { | |
| 24 | self.id = id | |
| 25 | self.name = name | |
| 26 | self.username = username | |
| 27 | self.password = password | |
| 28 | self.url = url | |
| 29 | self.notes = notes | |
| 30 | self.tags = Self.normalize(tags: tags) | |
| 31 | let stamp = Self.truncateToSeconds(now) | |
| 32 | created = stamp | |
| 33 | updated = stamp | |
| 34 | } | |
| 35 | ||
| 36 | public static func normalize(tags: [String]) -> [String] { | |
| 37 | var seen: Set<String> = [] | |
| 38 | var out: [String] = [] | |
| 39 | for raw in tags { | |
| 40 | let tag = raw.trimmingCharacters(in: .whitespaces) | |
| 41 | guard !tag.isEmpty, seen.insert(tag.lowercased()).inserted else { continue } | |
| 42 | out.append(tag) | |
| 43 | } | |
| 44 | return out.sorted { a, b in | |
| 45 | let (la, lb) = (a.lowercased(), b.lowercased()) | |
| 46 | return la == lb ? a < b : la < lb | |
| 47 | } | |
| 48 | } | |
| 49 | ||
| 50 | public static func truncateToSeconds(_ date: Date) -> Date { | |
| 51 | Date(timeIntervalSince1970: date.timeIntervalSince1970.rounded(.down)) | |
| 52 | } | |
| 53 | ||
| 54 | public func hasTag(_ tag: String) -> Bool { | |
| 55 | let needle = tag.lowercased() | |
| 56 | return tags.contains { $0.lowercased() == needle } | |
| 57 | } | |
| 58 | ||
| 59 | public func matches(_ query: String) -> Bool { | |
| 60 | let needle = query.lowercased() | |
| 61 | guard !needle.isEmpty else { return false } | |
| 62 | let haystacks = [name, username ?? "", url ?? "", notes ?? ""] + tags | |
| 63 | return haystacks.contains { $0.lowercased().contains(needle) } | |
| 64 | } | |
| 65 | } | |
Sources/KeycaskCore/EntryID.swift added +45
| @@ -0,0 +1,45 @@ | ||
| 1 | public struct EntryID: Hashable, Sendable, CustomStringConvertible { | |
| 2 | public static let alphabet: [Character] = Array("abcdefghijkmnpqrstuvwxyz23456789") | |
| 3 | public static let length = 8 | |
| 4 | ||
| 5 | public let rawValue: String | |
| 6 | ||
| 7 | public init?(_ raw: String) { | |
| 8 | guard raw.count == Self.length else { return nil } | |
| 9 | let allowed = Set(Self.alphabet) | |
| 10 | guard raw.allSatisfy({ allowed.contains($0) }) else { return nil } | |
| 11 | rawValue = raw | |
| 12 | } | |
| 13 | ||
| 14 | public static func random() -> EntryID { | |
| 15 | var rng = SystemRandomNumberGenerator() | |
| 16 | return random(using: &rng) | |
| 17 | } | |
| 18 | ||
| 19 | public static func random(using rng: inout some RandomNumberGenerator) -> EntryID { | |
| 20 | var chars: [Character] = [] | |
| 21 | chars.reserveCapacity(length) | |
| 22 | for _ in 0..<length { | |
| 23 | chars.append(alphabet[Int(rng.next(upperBound: UInt32(alphabet.count)))]) | |
| 24 | } | |
| 25 | return EntryID(String(chars))! | |
| 26 | } | |
| 27 | ||
| 28 | public var description: String { rawValue } | |
| 29 | } | |
| 30 | ||
| 31 | extension EntryID: Codable { | |
| 32 | public init(from decoder: any Decoder) throws { | |
| 33 | let raw = try decoder.singleValueContainer().decode(String.self) | |
| 34 | guard let id = EntryID(raw) else { | |
| 35 | throw DecodingError.dataCorrupted( | |
| 36 | .init(codingPath: decoder.codingPath, debugDescription: "invalid entry id \(raw)")) | |
| 37 | } | |
| 38 | self = id | |
| 39 | } | |
| 40 | ||
| 41 | public func encode(to encoder: any Encoder) throws { | |
| 42 | var container = encoder.singleValueContainer() | |
| 43 | try container.encode(rawValue) | |
| 44 | } | |
| 45 | } | |
Sources/KeycaskCore/Envelope.swift added +109
| @@ -0,0 +1,109 @@ | ||
| 1 | import Crypto | |
| 2 | import Foundation | |
| 3 | import _CryptoExtras | |
| 4 | ||
| 5 | public struct Envelope: Codable, Equatable, Sendable { | |
| 6 | public struct KDFParams: Codable, Equatable, Sendable { | |
| 7 | public var name: String | |
| 8 | public var iterations: Int | |
| 9 | public var salt: Data | |
| 10 | ||
| 11 | public init(name: String, iterations: Int, salt: Data) { | |
| 12 | self.name = name | |
| 13 | self.iterations = iterations | |
| 14 | self.salt = salt | |
| 15 | } | |
| 16 | ||
| 17 | public static func fresh(iterations: Int = Envelope.defaultIterations) -> KDFParams { | |
| 18 | var rng = SystemRandomNumberGenerator() | |
| 19 | let salt = Data( | |
| 20 | (0..<Envelope.saltLength).map { _ in UInt8.random(in: .min ... .max, using: &rng) }) | |
| 21 | return KDFParams(name: Envelope.kdfName, iterations: iterations, salt: salt) | |
| 22 | } | |
| 23 | } | |
| 24 | ||
| 25 | public static let currentFormat = 1 | |
| 26 | public static let defaultIterations = 600_000 | |
| 27 | public static let kdfName = "pbkdf2-hmac-sha256" | |
| 28 | public static let saltLength = 16 | |
| 29 | static let keyLength = 32 | |
| 30 | static let minimumBoxLength = 12 + 16 | |
| 31 | ||
| 32 | public var format: Int | |
| 33 | public var kdf: KDFParams | |
| 34 | public var box: Data | |
| 35 | ||
| 36 | public static func seal(_ plaintext: Data, passphrase: String, kdf: KDFParams) throws | |
| 37 | -> Envelope | |
| 38 | { | |
| 39 | let key = try deriveKey(passphrase: passphrase, kdf: kdf) | |
| 40 | do { | |
| 41 | let sealed = try ChaChaPoly.seal(plaintext, using: key) | |
| 42 | return Envelope(format: currentFormat, kdf: kdf, box: sealed.combined) | |
| 43 | } catch { | |
| 44 | throw KeycaskError.failure("encrypt: \(error)") | |
| 45 | } | |
| 46 | } | |
| 47 | ||
| 48 | public func open(passphrase: String) throws -> Data { | |
| 49 | guard format == Self.currentFormat else { | |
| 50 | throw KeycaskError.corrupt("unsupported format \(format)") | |
| 51 | } | |
| 52 | guard kdf.name == Self.kdfName else { | |
| 53 | throw KeycaskError.corrupt("unsupported kdf \(kdf.name)") | |
| 54 | } | |
| 55 | guard box.count >= Self.minimumBoxLength else { | |
| 56 | throw KeycaskError.corrupt("box too short") | |
| 57 | } | |
| 58 | let key = try Self.deriveKey(passphrase: passphrase, kdf: kdf) | |
| 59 | let sealed: ChaChaPoly.SealedBox | |
| 60 | do { | |
| 61 | sealed = try ChaChaPoly.SealedBox(combined: box) | |
| 62 | } catch { | |
| 63 | throw KeycaskError.corrupt("box is malformed") | |
| 64 | } | |
| 65 | do { | |
| 66 | return try ChaChaPoly.open(sealed, using: key) | |
| 67 | } catch { | |
| 68 | throw KeycaskError.cannotDecrypt | |
| 69 | } | |
| 70 | } | |
| 71 | ||
| 72 | public init(parsing data: Data) throws { | |
| 73 | do { | |
| 74 | self = try JSONDecoder().decode(Envelope.self, from: data) | |
| 75 | } catch { | |
| 76 | throw KeycaskError.corrupt("not a keycask vault: \(error)") | |
| 77 | } | |
| 78 | } | |
| 79 | ||
| 80 | public func encoded() throws -> Data { | |
| 81 | let encoder = JSONEncoder() | |
| 82 | encoder.outputFormatting = [.sortedKeys, .prettyPrinted] | |
| 83 | do { | |
| 84 | return try encoder.encode(self) | |
| 85 | } catch { | |
| 86 | throw KeycaskError.io("encode envelope: \(error)") | |
| 87 | } | |
| 88 | } | |
| 89 | ||
| 90 | init(format: Int, kdf: KDFParams, box: Data) { | |
| 91 | self.format = format | |
| 92 | self.kdf = kdf | |
| 93 | self.box = box | |
| 94 | } | |
| 95 | ||
| 96 | static func deriveKey(passphrase: String, kdf: KDFParams) throws -> SymmetricKey { | |
| 97 | guard (1...Int(UInt32.max)).contains(kdf.iterations) else { | |
| 98 | throw KeycaskError.corrupt("bad iteration count \(kdf.iterations)") | |
| 99 | } | |
| 100 | let normalized = Array(passphrase.precomposedStringWithCanonicalMapping.utf8) | |
| 101 | do { | |
| 102 | return try KDF.Insecure.PBKDF2.deriveKey( | |
| 103 | from: normalized, salt: kdf.salt, using: .sha256, | |
| 104 | outputByteCount: keyLength, unsafeUncheckedRounds: kdf.iterations) | |
| 105 | } catch { | |
| 106 | throw KeycaskError.failure("derive key: \(error)") | |
| 107 | } | |
| 108 | } | |
| 109 | } | |
Sources/KeycaskCore/Generator.swift added +37
| @@ -0,0 +1,37 @@ | ||
| 1 | public enum Generator { | |
| 2 | public static let alphabet: [Character] = Array( | |
| 3 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+[]{};:,.<>?" | |
| 4 | ) | |
| 5 | public static let defaultLength = 24 | |
| 6 | public static let wordSeparator = "-" | |
| 7 | ||
| 8 | public static func password(length: Int) -> String { | |
| 9 | var rng = SystemRandomNumberGenerator() | |
| 10 | return password(length: length, using: &rng) | |
| 11 | } | |
| 12 | ||
| 13 | public static func password(length: Int, using rng: inout some RandomNumberGenerator) -> String | |
| 14 | { | |
| 15 | var chars: [Character] = [] | |
| 16 | chars.reserveCapacity(max(length, 0)) | |
| 17 | for _ in 0..<max(length, 0) { | |
| 18 | chars.append(alphabet[Int(rng.next(upperBound: UInt32(alphabet.count)))]) | |
| 19 | } | |
| 20 | return String(chars) | |
| 21 | } | |
| 22 | ||
| 23 | public static func passphrase(words: Int) -> String { | |
| 24 | var rng = SystemRandomNumberGenerator() | |
| 25 | return passphrase(words: words, using: &rng) | |
| 26 | } | |
| 27 | ||
| 28 | public static func passphrase(words: Int, using rng: inout some RandomNumberGenerator) -> String | |
| 29 | { | |
| 30 | let list = Wordlist.words | |
| 31 | var picked: [String] = [] | |
| 32 | for _ in 0..<max(words, 0) { | |
| 33 | picked.append(list[Int(rng.next(upperBound: UInt32(list.count)))]) | |
| 34 | } | |
| 35 | return picked.joined(separator: wordSeparator) | |
| 36 | } | |
| 37 | } | |
Sources/KeycaskCore/KeycaskError.swift added +40
| @@ -0,0 +1,40 @@ | ||
| 1 | public enum KeycaskError: Error, Equatable, Sendable { | |
| 2 | case notFound(String) | |
| 3 | case ambiguous(name: String, candidates: [Entry]) | |
| 4 | case cannotDecrypt | |
| 5 | case corrupt(String) | |
| 6 | case vaultExists(String) | |
| 7 | case noVault(String) | |
| 8 | case duplicateID(EntryID) | |
| 9 | case io(String) | |
| 10 | case usage(String) | |
| 11 | case failure(String) | |
| 12 | ||
| 13 | public var exitCode: Int32 { | |
| 14 | switch self { | |
| 15 | case .failure, .io, .corrupt, .vaultExists, .duplicateID: 1 | |
| 16 | case .usage: 2 | |
| 17 | case .notFound, .noVault: 3 | |
| 18 | case .cannotDecrypt: 4 | |
| 19 | case .ambiguous: 5 | |
| 20 | } | |
| 21 | } | |
| 22 | ||
| 23 | public var message: String { | |
| 24 | switch self { | |
| 25 | case .notFound(let what): "\(what): not found" | |
| 26 | case .ambiguous(let name, let candidates): | |
| 27 | (["\(name): ambiguous, use an id:"] | |
| 28 | + candidates.map { " \($0.id.rawValue) \($0.username ?? "") \($0.url ?? "")" }) | |
| 29 | .joined(separator: "\n") | |
| 30 | case .cannotDecrypt: "cannot decrypt: wrong passphrase or damaged vault" | |
| 31 | case .corrupt(let why): "vault is corrupt: \(why)" | |
| 32 | case .vaultExists(let path): "vault \(path) already exists" | |
| 33 | case .noVault(let path): "vault \(path) not found (run `keycask init`)" | |
| 34 | case .duplicateID(let id): "duplicate id \(id.rawValue)" | |
| 35 | case .io(let why): why | |
| 36 | case .usage(let why): why | |
| 37 | case .failure(let why): why | |
| 38 | } | |
| 39 | } | |
| 40 | } | |
Sources/KeycaskCore/Vault.swift added +65
| @@ -0,0 +1,65 @@ | ||
| 1 | import Foundation | |
| 2 | ||
| 3 | public struct Vault: Codable, Equatable, Sendable { | |
| 4 | public var entries: [Entry] | |
| 5 | ||
| 6 | public init(entries: [Entry] = []) { | |
| 7 | self.entries = entries | |
| 8 | } | |
| 9 | ||
| 10 | public func entry(id: EntryID) -> Entry? { | |
| 11 | entries.first { $0.id == id } | |
| 12 | } | |
| 13 | ||
| 14 | public mutating func add(_ entry: Entry) throws { | |
| 15 | guard self.entry(id: entry.id) == nil else { throw KeycaskError.duplicateID(entry.id) } | |
| 16 | var normalized = entry | |
| 17 | normalized.tags = Entry.normalize(tags: entry.tags) | |
| 18 | entries.append(normalized) | |
| 19 | } | |
| 20 | ||
| 21 | public mutating func remove(id: EntryID) throws { | |
| 22 | guard let index = entries.firstIndex(where: { $0.id == id }) else { | |
| 23 | throw KeycaskError.notFound(id.rawValue) | |
| 24 | } | |
| 25 | entries.remove(at: index) | |
| 26 | } | |
| 27 | ||
| 28 | public mutating func update( | |
| 29 | id: EntryID, now: Date = .now, _ change: (inout Entry) -> Void | |
| 30 | ) throws { | |
| 31 | guard let index = entries.firstIndex(where: { $0.id == id }) else { | |
| 32 | throw KeycaskError.notFound(id.rawValue) | |
| 33 | } | |
| 34 | change(&entries[index]) | |
| 35 | entries[index].tags = Entry.normalize(tags: entries[index].tags) | |
| 36 | entries[index].updated = Entry.truncateToSeconds(now) | |
| 37 | } | |
| 38 | ||
| 39 | public func resolve(_ ref: String) throws -> Entry { | |
| 40 | if let id = EntryID(ref), let hit = entry(id: id) { | |
| 41 | return hit | |
| 42 | } | |
| 43 | let byName = entries.filter { $0.name == ref } | |
| 44 | switch byName.count { | |
| 45 | case 0: throw KeycaskError.notFound(ref) | |
| 46 | case 1: return byName[0] | |
| 47 | default: throw KeycaskError.ambiguous(name: ref, candidates: byName) | |
| 48 | } | |
| 49 | } | |
| 50 | ||
| 51 | public func filter(tag: String) -> [Entry] { | |
| 52 | sortedEntries.filter { $0.hasTag(tag) } | |
| 53 | } | |
| 54 | ||
| 55 | public func search(_ query: String) -> [Entry] { | |
| 56 | sortedEntries.filter { $0.matches(query) } | |
| 57 | } | |
| 58 | ||
| 59 | public var sortedEntries: [Entry] { | |
| 60 | entries.sorted { a, b in | |
| 61 | let (la, lb) = (a.name.lowercased(), b.name.lowercased()) | |
| 62 | return la == lb ? a.id.rawValue < b.id.rawValue : la < lb | |
| 63 | } | |
| 64 | } | |
| 65 | } | |
Sources/KeycaskCore/VaultCodec.swift added +32
| @@ -0,0 +1,32 @@ | ||
| 1 | import Foundation | |
| 2 | ||
| 3 | public enum VaultCodec { | |
| 4 | public static func makeEncoder() -> JSONEncoder { | |
| 5 | let encoder = JSONEncoder() | |
| 6 | encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes] | |
| 7 | encoder.dateEncodingStrategy = .iso8601 | |
| 8 | return encoder | |
| 9 | } | |
| 10 | ||
| 11 | public static func makeDecoder() -> JSONDecoder { | |
| 12 | let decoder = JSONDecoder() | |
| 13 | decoder.dateDecodingStrategy = .iso8601 | |
| 14 | return decoder | |
| 15 | } | |
| 16 | ||
| 17 | public static func encode(_ vault: Vault) throws -> Data { | |
| 18 | do { | |
| 19 | return try makeEncoder().encode(vault) | |
| 20 | } catch { | |
| 21 | throw KeycaskError.io("encode vault: \(error)") | |
| 22 | } | |
| 23 | } | |
| 24 | ||
| 25 | public static func decode(_ data: Data) throws -> Vault { | |
| 26 | do { | |
| 27 | return try makeDecoder().decode(Vault.self, from: data) | |
| 28 | } catch { | |
| 29 | throw KeycaskError.corrupt("\(error)") | |
| 30 | } | |
| 31 | } | |
| 32 | } | |
Sources/KeycaskCore/Wordlist.swift added +7784
| @@ -0,0 +1,7784 @@ | ||
| 1 | // swift-format-ignore-file | |
| 2 | // EFF long word list, https://www.eff.org/dice. See NOTICE. | |
| 3 | let effLongWordlist = """ | |
| 4 | abacus | |
| 5 | abdomen | |
| 6 | abdominal | |
| 7 | abide | |
| 8 | abiding | |
| 9 | ability | |
| 10 | ablaze | |
| 11 | able | |
| 12 | abnormal | |
| 13 | abrasion | |
| 14 | abrasive | |
| 15 | abreast | |
| 16 | abridge | |
| 17 | abroad | |
| 18 | abruptly | |
| 19 | absence | |
| 20 | absentee | |
| 21 | absently | |
| 22 | absinthe | |
| 23 | absolute | |
| 24 | absolve | |
| 25 | abstain | |
| 26 | abstract | |
| 27 | absurd | |
| 28 | accent | |
| 29 | acclaim | |
| 30 | acclimate | |
| 31 | accompany | |
| 32 | account | |
| 33 | accuracy | |
| 34 | accurate | |
| 35 | accustom | |
| 36 | acetone | |
| 37 | achiness | |
| 38 | aching | |
| 39 | acid | |
| 40 | acorn | |
| 41 | acquaint | |
| 42 | acquire | |
| 43 | acre | |
| 44 | acrobat | |
| 45 | acronym | |
| 46 | acting | |
| 47 | action | |
| 48 | activate | |
| 49 | activator | |
| 50 | active | |
| 51 | activism | |
| 52 | activist | |
| 53 | activity | |
| 54 | actress | |
| 55 | acts | |
| 56 | acutely | |
| 57 | acuteness | |
| 58 | aeration | |
| 59 | aerobics | |
| 60 | aerosol | |
| 61 | aerospace | |
| 62 | afar | |
| 63 | affair | |
| 64 | affected | |
| 65 | affecting | |
| 66 | affection | |
| 67 | affidavit | |
| 68 | affiliate | |
| 69 | affirm | |
| 70 | affix | |
| 71 | afflicted | |
| 72 | affluent | |
| 73 | afford | |
| 74 | affront | |
| 75 | aflame | |
| 76 | afloat | |
| 77 | aflutter | |
| 78 | afoot | |
| 79 | afraid | |
| 80 | afterglow | |
| 81 | afterlife | |
| 82 | aftermath | |
| 83 | aftermost | |
| 84 | afternoon | |
| 85 | aged | |
| 86 | ageless | |
| 87 | agency | |
| 88 | agenda | |
| 89 | agent | |
| 90 | aggregate | |
| 91 | aghast | |
| 92 | agile | |
| 93 | agility | |
| 94 | aging | |
| 95 | agnostic | |
| 96 | agonize | |
| 97 | agonizing | |
| 98 | agony | |
| 99 | agreeable | |
| 100 | agreeably | |
| 101 | agreed | |
| 102 | agreeing | |
| 103 | agreement | |
| 104 | aground | |
| 105 | ahead | |
| 106 | ahoy | |
| 107 | aide | |
| 108 | aids | |
| 109 | aim | |
| 110 | ajar | |
| 111 | alabaster | |
| 112 | alarm | |
| 113 | albatross | |
| 114 | album | |
| 115 | alfalfa | |
| 116 | algebra | |
| 117 | algorithm | |
| 118 | alias | |
| 119 | alibi | |
| 120 | alienable | |
| 121 | alienate | |
| 122 | aliens | |
| 123 | alike | |
| 124 | alive | |
| 125 | alkaline | |
| 126 | alkalize | |
| 127 | almanac | |
| 128 | almighty | |
| 129 | almost | |
| 130 | aloe | |
| 131 | aloft | |
| 132 | aloha | |
| 133 | alone | |
| 134 | alongside | |
| 135 | aloof | |
| 136 | alphabet | |
| 137 | alright | |
| 138 | although | |
| 139 | altitude | |
| 140 | alto | |
| 141 | aluminum | |
| 142 | alumni | |
| 143 | always | |
| 144 | amaretto | |
| 145 | amaze | |
| 146 | amazingly | |
| 147 | amber | |
| 148 | ambiance | |
| 149 | ambiguity | |
| 150 | ambiguous | |
| 151 | ambition | |
| 152 | ambitious | |
| 153 | ambulance | |
| 154 | ambush | |
| 155 | amendable | |
| 156 | amendment | |
| 157 | amends | |
| 158 | amenity | |
| 159 | amiable | |
| 160 | amicably | |
| 161 | amid | |
| 162 | amigo | |
| 163 | amino | |
| 164 | amiss | |
| 165 | ammonia | |
| 166 | ammonium | |
| 167 | amnesty | |
| 168 | amniotic | |
| 169 | among | |
| 170 | amount | |
| 171 | amperage | |
| 172 | ample | |
| 173 | amplifier | |
| 174 | amplify | |
| 175 | amply | |
| 176 | amuck | |
| 177 | amulet | |
| 178 | amusable | |
| 179 | amused | |
| 180 | amusement | |
| 181 | amuser | |
| 182 | amusing | |
| 183 | anaconda | |
| 184 | anaerobic | |
| 185 | anagram | |
| 186 | anatomist | |
| 187 | anatomy | |
| 188 | anchor | |
| 189 | anchovy | |
| 190 | ancient | |
| 191 | android | |
| 192 | anemia | |
| 193 | anemic | |
| 194 | aneurism | |
| 195 | anew | |
| 196 | angelfish | |
| 197 | angelic | |
| 198 | anger | |
| 199 | angled | |
| 200 | angler | |
| 201 | angles | |
| 202 | angling | |
| 203 | angrily | |
| 204 | angriness | |
| 205 | anguished | |
| 206 | angular | |
| 207 | animal | |
| 208 | animate | |
| 209 | animating | |
| 210 | animation | |
| 211 | animator | |
| 212 | anime | |
| 213 | animosity | |
| 214 | ankle | |
| 215 | annex | |
| 216 | annotate | |
| 217 | announcer | |
| 218 | annoying | |
| 219 | annually | |
| 220 | annuity | |
| 221 | anointer | |
| 222 | another | |
| 223 | answering | |
| 224 | antacid | |
| 225 | antarctic | |
| 226 | anteater | |
| 227 | antelope | |
| 228 | antennae | |
| 229 | anthem | |
| 230 | anthill | |
| 231 | anthology | |
| 232 | antibody | |
| 233 | antics | |
| 234 | antidote | |
| 235 | antihero | |
| 236 | antiquely | |
| 237 | antiques | |
| 238 | antiquity | |
| 239 | antirust | |
| 240 | antitoxic | |
| 241 | antitrust | |
| 242 | antiviral | |
| 243 | antivirus | |
| 244 | antler | |
| 245 | antonym | |
| 246 | antsy | |
| 247 | anvil | |
| 248 | anybody | |
| 249 | anyhow | |
| 250 | anymore | |
| 251 | anyone | |
| 252 | anyplace | |
| 253 | anything | |
| 254 | anytime | |
| 255 | anyway | |
| 256 | anywhere | |
| 257 | aorta | |
| 258 | apache | |
| 259 | apostle | |
| 260 | appealing | |
| 261 | appear | |
| 262 | appease | |
| 263 | appeasing | |
| 264 | appendage | |
| 265 | appendix | |
| 266 | appetite | |
| 267 | appetizer | |
| 268 | applaud | |
| 269 | applause | |
| 270 | apple | |
| 271 | appliance | |
| 272 | applicant | |
| 273 | applied | |
| 274 | apply | |
| 275 | appointee | |
| 276 | appraisal | |
| 277 | appraiser | |
| 278 | apprehend | |
| 279 | approach | |
| 280 | approval | |
| 281 | approve | |
| 282 | apricot | |
| 283 | april | |
| 284 | apron | |
| 285 | aptitude | |
| 286 | aptly | |
| 287 | aqua | |
| 288 | aqueduct | |
| 289 | arbitrary | |
| 290 | arbitrate | |
| 291 | ardently | |
| 292 | area | |
| 293 | arena | |
| 294 | arguable | |
| 295 | arguably | |
| 296 | argue | |
| 297 | arise | |
| 298 | armadillo | |
| 299 | armband | |
| 300 | armchair | |
| 301 | armed | |
| 302 | armful | |
| 303 | armhole | |
| 304 | arming | |
| 305 | armless | |
| 306 | armoire | |
| 307 | armored | |
| 308 | armory | |
| 309 | armrest | |
| 310 | army | |
| 311 | aroma | |
| 312 | arose | |
| 313 | around | |
| 314 | arousal | |
| 315 | arrange | |
| 316 | array | |
| 317 | arrest | |
| 318 | arrival | |
| 319 | arrive | |
| 320 | arrogance | |
| 321 | arrogant | |
| 322 | arson | |
| 323 | art | |
| 324 | ascend | |
| 325 | ascension | |
| 326 | ascent | |
| 327 | ascertain | |
| 328 | ashamed | |
| 329 | ashen | |
| 330 | ashes | |
| 331 | ashy | |
| 332 | aside | |
| 333 | askew | |
| 334 | asleep | |
| 335 | asparagus | |
| 336 | aspect | |
| 337 | aspirate | |
| 338 | aspire | |
| 339 | aspirin | |
| 340 | astonish | |
| 341 | astound | |
| 342 | astride | |
| 343 | astrology | |
| 344 | astronaut | |
| 345 | astronomy | |
| 346 | astute | |
| 347 | atlantic | |
| 348 | atlas | |
| 349 | atom | |
| 350 | atonable | |
| 351 | atop | |
| 352 | atrium | |
| 353 | atrocious | |
| 354 | atrophy | |
| 355 | attach | |
| 356 | attain | |
| 357 | attempt | |
| 358 | attendant | |
| 359 | attendee | |
| 360 | attention | |
| 361 | attentive | |
| 362 | attest | |
| 363 | attic | |
| 364 | attire | |
| 365 | attitude | |
| 366 | attractor | |
| 367 | attribute | |
| 368 | atypical | |
| 369 | auction | |
| 370 | audacious | |
| 371 | audacity | |
| 372 | audible | |
| 373 | audibly | |
| 374 | audience | |
| 375 | audio | |
| 376 | audition | |
| 377 | augmented | |
| 378 | august | |
| 379 | authentic | |
| 380 | author | |
| 381 | autism | |
| 382 | autistic | |
| 383 | autograph | |
| 384 | automaker | |
| 385 | automated | |
| 386 | automatic | |
| 387 | autopilot | |
| 388 | available | |
| 389 | avalanche | |
| 390 | avatar | |
| 391 | avenge | |
| 392 | avenging | |
| 393 | avenue | |
| 394 | average | |
| 395 | aversion | |
| 396 | avert | |
| 397 | aviation | |
| 398 | aviator | |
| 399 | avid | |
| 400 | avoid | |
| 401 | await | |
| 402 | awaken | |
| 403 | award | |
| 404 | aware | |
| 405 | awhile | |
| 406 | awkward | |
| 407 | awning | |
| 408 | awoke | |
| 409 | awry | |
| 410 | axis | |
| 411 | babble | |
| 412 | babbling | |
| 413 | babied | |
| 414 | baboon | |
| 415 | backache | |
| 416 | backboard | |
| 417 | backboned | |
| 418 | backdrop | |
| 419 | backed | |
| 420 | backer | |
| 421 | backfield | |
| 422 | backfire | |
| 423 | backhand | |
| 424 | backing | |
| 425 | backlands | |
| 426 | backlash | |
| 427 | backless | |
| 428 | backlight | |
| 429 | backlit | |
| 430 | backlog | |
| 431 | backpack | |
| 432 | backpedal | |
| 433 | backrest | |
| 434 | backroom | |
| 435 | backshift | |
| 436 | backside | |
| 437 | backslid | |
| 438 | backspace | |
| 439 | backspin | |
| 440 | backstab | |
| 441 | backstage | |
| 442 | backtalk | |
| 443 | backtrack | |
| 444 | backup | |
| 445 | backward | |
| 446 | backwash | |
| 447 | backwater | |
| 448 | backyard | |
| 449 | bacon | |
| 450 | bacteria | |
| 451 | bacterium | |
| 452 | badass | |
| 453 | badge | |
| 454 | badland | |
| 455 | badly | |
| 456 | badness | |
| 457 | baffle | |
| 458 | baffling | |
| 459 | bagel | |
| 460 | bagful | |
| 461 | baggage | |
| 462 | bagged | |
| 463 | baggie | |
| 464 | bagginess | |
| 465 | bagging | |
| 466 | baggy | |
| 467 | bagpipe | |
| 468 | baguette | |
| 469 | baked | |
| 470 | bakery | |
| 471 | bakeshop | |
| 472 | baking | |
| 473 | balance | |
| 474 | balancing | |
| 475 | balcony | |
| 476 | balmy | |
| 477 | balsamic | |
| 478 | bamboo | |
| 479 | banana | |
| 480 | banish | |
| 481 | banister | |
| 482 | banjo | |
| 483 | bankable | |
| 484 | bankbook | |
| 485 | banked | |
| 486 | banker | |
| 487 | banking | |
| 488 | banknote | |
| 489 | bankroll | |
| 490 | banner | |
| 491 | bannister | |
| 492 | banshee | |
| 493 | banter | |
| 494 | barbecue | |
| 495 | barbed | |
| 496 | barbell | |
| 497 | barber | |
| 498 | barcode | |
| 499 | barge | |
| 500 | bargraph | |
| 501 | barista | |
| 502 | baritone | |
| 503 | barley | |
| 504 | barmaid | |
| 505 | barman | |
| 506 | barn | |
| 507 | barometer | |
| 508 | barrack | |
| 509 | barracuda | |
| 510 | barrel | |
| 511 | barrette | |
| 512 | barricade | |
| 513 | barrier | |
| 514 | barstool | |
| 515 | bartender | |
| 516 | barterer | |
| 517 | bash | |
| 518 | basically | |
| 519 | basics | |
| 520 | basil | |
| 521 | basin | |
| 522 | basis | |
| 523 | basket | |
| 524 | batboy | |
| 525 | batch | |
| 526 | bath | |
| 527 | baton | |
| 528 | bats | |
| 529 | battalion | |
| 530 | battered | |
| 531 | battering | |
| 532 | battery | |
| 533 | batting | |
| 534 | battle | |
| 535 | bauble | |
| 536 | bazooka | |
| 537 | blabber | |
| 538 | bladder | |
| 539 | blade | |
| 540 | blah | |
| 541 | blame | |
| 542 | blaming | |
| 543 | blanching | |
| 544 | blandness | |
| 545 | blank | |
| 546 | blaspheme | |
| 547 | blasphemy | |
| 548 | blast | |
| 549 | blatancy | |
| 550 | blatantly | |
| 551 | blazer | |
| 552 | blazing | |
| 553 | bleach | |
| 554 | bleak | |
| 555 | bleep | |
| 556 | blemish | |
| 557 | blend | |
| 558 | bless | |
| 559 | blighted | |
| 560 | blimp | |
| 561 | bling | |
| 562 | blinked | |
| 563 | blinker | |
| 564 | blinking | |
| 565 | blinks | |
| 566 | blip | |
| 567 | blissful | |
| 568 | blitz | |
| 569 | blizzard | |
| 570 | bloated | |
| 571 | bloating | |
| 572 | blob | |
| 573 | blog | |
| 574 | bloomers | |
| 575 | blooming | |
| 576 | blooper | |
| 577 | blot | |
| 578 | blouse | |
| 579 | blubber | |
| 580 | bluff | |
| 581 | bluish | |
| 582 | blunderer | |
| 583 | blunt | |
| 584 | blurb | |
| 585 | blurred | |
| 586 | blurry | |
| 587 | blurt | |
| 588 | blush | |
| 589 | blustery | |
| 590 | boaster | |
| 591 | boastful | |
| 592 | boasting | |
| 593 | boat | |
| 594 | bobbed | |
| 595 | bobbing | |
| 596 | bobble | |
| 597 | bobcat | |
| 598 | bobsled | |
| 599 | bobtail | |
| 600 | bodacious | |
| 601 | body | |
| 602 | bogged | |
| 603 | boggle | |
| 604 | bogus | |
| 605 | boil | |
| 606 | bok | |
| 607 | bolster | |
| 608 | bolt | |
| 609 | bonanza | |
| 610 | bonded | |
| 611 | bonding | |
| 612 | bondless | |
| 613 | boned | |
| 614 | bonehead | |
| 615 | boneless | |
| 616 | bonelike | |
| 617 | boney | |
| 618 | bonfire | |
| 619 | bonnet | |
| 620 | bonsai | |
| 621 | bonus | |
| 622 | bony | |
| 623 | boogeyman | |
| 624 | boogieman | |
| 625 | book | |
| 626 | boondocks | |
| 627 | booted | |
| 628 | booth | |
| 629 | bootie | |
| 630 | booting | |
| 631 | bootlace | |
| 632 | bootleg | |
| 633 | boots | |
| 634 | boozy | |
| 635 | borax | |
| 636 | boring | |
| 637 | borough | |
| 638 | borrower | |
| 639 | borrowing | |
| 640 | boss | |
| 641 | botanical | |
| 642 | botanist | |
| 643 | botany | |
| 644 | botch | |
| 645 | both | |
| 646 | bottle | |
| 647 | bottling | |
| 648 | bottom | |
| 649 | bounce | |
| 650 | bouncing | |
| 651 | bouncy | |
| 652 | bounding | |
| 653 | boundless | |
| 654 | bountiful | |
| 655 | bovine | |
| 656 | boxcar | |
| 657 | boxer | |
| 658 | boxing | |
| 659 | boxlike | |
| 660 | boxy | |
| 661 | breach | |
| 662 | breath | |
| 663 | breeches | |
| 664 | breeching | |
| 665 | breeder | |
| 666 | breeding | |
| 667 | breeze | |
| 668 | breezy | |
| 669 | brethren | |
| 670 | brewery | |
| 671 | brewing | |
| 672 | briar | |
| 673 | bribe | |
| 674 | brick | |
| 675 | bride | |
| 676 | bridged | |
| 677 | brigade | |
| 678 | bright | |
| 679 | brilliant | |
| 680 | brim | |
| 681 | bring | |
| 682 | brink | |
| 683 | brisket | |
| 684 | briskly | |
| 685 | briskness | |
| 686 | bristle | |
| 687 | brittle | |
| 688 | broadband | |
| 689 | broadcast | |
| 690 | broaden | |
| 691 | broadly | |
| 692 | broadness | |
| 693 | broadside | |
| 694 | broadways | |
| 695 | broiler | |
| 696 | broiling | |
| 697 | broken | |
| 698 | broker | |
| 699 | bronchial | |
| 700 | bronco | |
| 701 | bronze | |
| 702 | bronzing | |
| 703 | brook | |
| 704 | broom | |
| 705 | brought | |
| 706 | browbeat | |
| 707 | brownnose | |
| 708 | browse | |
| 709 | browsing | |
| 710 | bruising | |
| 711 | brunch | |
| 712 | brunette | |
| 713 | brunt | |
| 714 | brush | |
| 715 | brussels | |
| 716 | brute | |
| 717 | brutishly | |
| 718 | bubble | |
| 719 | bubbling | |
| 720 | bubbly | |
| 721 | buccaneer | |
| 722 | bucked | |
| 723 | bucket | |
| 724 | buckle | |
| 725 | buckshot | |
| 726 | buckskin | |
| 727 | bucktooth | |
| 728 | buckwheat | |
| 729 | buddhism | |
| 730 | buddhist | |
| 731 | budding | |
| 732 | buddy | |
| 733 | budget | |
| 734 | buffalo | |
| 735 | buffed | |
| 736 | buffer | |
| 737 | buffing | |
| 738 | buffoon | |
| 739 | buggy | |
| 740 | bulb | |
| 741 | bulge | |
| 742 | bulginess | |
| 743 | bulgur | |
| 744 | bulk | |
| 745 | bulldog | |
| 746 | bulldozer | |
| 747 | bullfight | |
| 748 | bullfrog | |
| 749 | bullhorn | |
| 750 | bullion | |
| 751 | bullish | |
| 752 | bullpen | |
| 753 | bullring | |
| 754 | bullseye | |
| 755 | bullwhip | |
| 756 | bully | |
| 757 | bunch | |
| 758 | bundle | |
| 759 | bungee | |
| 760 | bunion | |
| 761 | bunkbed | |
| 762 | bunkhouse | |
| 763 | bunkmate | |
| 764 | bunny | |
| 765 | bunt | |
| 766 | busboy | |
| 767 | bush | |
| 768 | busily | |
| 769 | busload | |
| 770 | bust | |
| 771 | busybody | |
| 772 | buzz | |
| 773 | cabana | |
| 774 | cabbage | |
| 775 | cabbie | |
| 776 | cabdriver | |
| 777 | cable | |
| 778 | caboose | |
| 779 | cache | |
| 780 | cackle | |
| 781 | cacti | |
| 782 | cactus | |
| 783 | caddie | |
| 784 | caddy | |
| 785 | cadet | |
| 786 | cadillac | |
| 787 | cadmium | |
| 788 | cage | |
| 789 | cahoots | |
| 790 | cake | |
| 791 | calamari | |
| 792 | calamity | |
| 793 | calcium | |
| 794 | calculate | |
| 795 | calculus | |
| 796 | caliber | |
| 797 | calibrate | |
| 798 | calm | |
| 799 | caloric | |
| 800 | calorie | |
| 801 | calzone | |
| 802 | camcorder | |
| 803 | cameo | |
| 804 | camera | |
| 805 | camisole | |
| 806 | camper | |
| 807 | campfire | |
| 808 | camping | |
| 809 | campsite | |
| 810 | campus | |
| 811 | canal | |
| 812 | canary | |
| 813 | cancel | |
| 814 | candied | |
| 815 | candle | |
| 816 | candy | |
| 817 | cane | |
| 818 | canine | |
| 819 | canister | |
| 820 | cannabis | |
| 821 | canned | |
| 822 | canning | |
| 823 | cannon | |
| 824 | cannot | |
| 825 | canola | |
| 826 | canon | |
| 827 | canopener | |
| 828 | canopy | |
| 829 | canteen | |
| 830 | canyon | |
| 831 | capable | |
| 832 | capably | |
| 833 | capacity | |
| 834 | cape | |
| 835 | capillary | |
| 836 | capital | |
| 837 | capitol | |
| 838 | capped | |
| 839 | capricorn | |
| 840 | capsize | |
| 841 | capsule | |
| 842 | caption | |
| 843 | captivate | |
| 844 | captive | |
| 845 | captivity | |
| 846 | capture | |
| 847 | caramel | |
| 848 | carat | |
| 849 | caravan | |
| 850 | carbon | |
| 851 | cardboard | |
| 852 | carded | |
| 853 | cardiac | |
| 854 | cardigan | |
| 855 | cardinal | |
| 856 | cardstock | |
| 857 | carefully | |
| 858 | caregiver | |
| 859 | careless | |
| 860 | caress | |
| 861 | caretaker | |
| 862 | cargo | |
| 863 | caring | |
| 864 | carless | |
| 865 | carload | |
| 866 | carmaker | |
| 867 | carnage | |
| 868 | carnation | |
| 869 | carnival | |
| 870 | carnivore | |
| 871 | carol | |
| 872 | carpenter | |
| 873 | carpentry | |
| 874 | carpool | |
| 875 | carport | |
| 876 | carried | |
| 877 | carrot | |
| 878 | carrousel | |
| 879 | carry | |
| 880 | cartel | |
| 881 | cartload | |
| 882 | carton | |
| 883 | cartoon | |
| 884 | cartridge | |
| 885 | cartwheel | |
| 886 | carve | |
| 887 | carving | |
| 888 | carwash | |
| 889 | cascade | |
| 890 | case | |
| 891 | cash | |
| 892 | casing | |
| 893 | casino | |
| 894 | casket | |
| 895 | cassette | |
| 896 | casually | |
| 897 | casualty | |
| 898 | catacomb | |
| 899 | catalog | |
| 900 | catalyst | |
| 901 | catalyze | |
| 902 | catapult | |
| 903 | cataract | |
| 904 | catatonic | |
| 905 | catcall | |
| 906 | catchable | |
| 907 | catcher | |
| 908 | catching | |
| 909 | catchy | |
| 910 | caterer | |
| 911 | catering | |
| 912 | catfight | |
| 913 | catfish | |
| 914 | cathedral | |
| 915 | cathouse | |
| 916 | catlike | |
| 917 | catnap | |
| 918 | catnip | |
| 919 | catsup | |
| 920 | cattail | |
| 921 | cattishly | |
| 922 | cattle | |
| 923 | catty | |
| 924 | catwalk | |
| 925 | caucasian | |
| 926 | caucus | |
| 927 | causal | |
| 928 | causation | |
| 929 | cause | |
| 930 | causing | |
| 931 | cauterize | |
| 932 | caution | |
| 933 | cautious | |
| 934 | cavalier | |
| 935 | cavalry | |
| 936 | caviar | |
| 937 | cavity | |
| 938 | cedar | |
| 939 | celery | |
| 940 | celestial | |
| 941 | celibacy | |
| 942 | celibate | |
| 943 | celtic | |
| 944 | cement | |
| 945 | census | |
| 946 | ceramics | |
| 947 | ceremony | |
| 948 | certainly | |
| 949 | certainty | |
| 950 | certified | |
| 951 | certify | |
| 952 | cesarean | |
| 953 | cesspool | |
| 954 | chafe | |
| 955 | chaffing | |
| 956 | chain | |
| 957 | chair | |
| 958 | chalice | |
| 959 | challenge | |
| 960 | chamber | |
| 961 | chamomile | |
| 962 | champion | |
| 963 | chance | |
| 964 | change | |
| 965 | channel | |
| 966 | chant | |
| 967 | chaos | |
| 968 | chaperone | |
| 969 | chaplain | |
| 970 | chapped | |
| 971 | chaps | |
| 972 | chapter | |
| 973 | character | |
| 974 | charbroil | |
| 975 | charcoal | |
| 976 | charger | |
| 977 | charging | |
| 978 | chariot | |
| 979 | charity | |
| 980 | charm | |
| 981 | charred | |
| 982 | charter | |
| 983 | charting | |
| 984 | chase | |
| 985 | chasing | |
| 986 | chaste | |
| 987 | chastise | |
| 988 | chastity | |
| 989 | chatroom | |
| 990 | chatter | |
| 991 | chatting | |
| 992 | chatty | |
| 993 | cheating | |
| 994 | cheddar | |
| 995 | cheek | |
| 996 | cheer | |
| 997 | cheese | |
| 998 | cheesy | |
| 999 | chef | |
| 1000 | chemicals | |
| 1001 | chemist | |
| 1002 | chemo | |
| 1003 | cherisher | |
| 1004 | cherub | |
| 1005 | chess | |
| 1006 | chest | |
| 1007 | chevron | |
| 1008 | chevy | |
| 1009 | chewable | |
| 1010 | chewer | |
| 1011 | chewing | |
| 1012 | chewy | |
| 1013 | chief | |
| 1014 | chihuahua | |
| 1015 | childcare | |
| 1016 | childhood | |
| 1017 | childish | |
| 1018 | childless | |
| 1019 | childlike | |
| 1020 | chili | |
| 1021 | chill | |
| 1022 | chimp | |
| 1023 | chip | |
| 1024 | chirping | |
| 1025 | chirpy | |
| 1026 | chitchat | |
| 1027 | chivalry | |
| 1028 | chive | |
| 1029 | chloride | |
| 1030 | chlorine | |
| 1031 | choice | |
| 1032 | chokehold | |
| 1033 | choking | |
| 1034 | chomp | |
| 1035 | chooser | |
| 1036 | choosing | |
| 1037 | choosy | |
| 1038 | chop | |
| 1039 | chosen | |
| 1040 | chowder | |
| 1041 | chowtime | |
| 1042 | chrome | |
| 1043 | chubby | |
| 1044 | chuck | |
| 1045 | chug | |
| 1046 | chummy | |
| 1047 | chump | |
| 1048 | chunk | |
| 1049 | churn | |
| 1050 | chute | |
| 1051 | cider | |
| 1052 | cilantro | |
| 1053 | cinch | |
| 1054 | cinema | |
| 1055 | cinnamon | |
| 1056 | circle | |
| 1057 | circling | |
| 1058 | circular | |
| 1059 | circulate | |
| 1060 | circus | |
| 1061 | citable | |
| 1062 | citadel | |
| 1063 | citation | |
| 1064 | citizen | |
| 1065 | citric | |
| 1066 | citrus | |
| 1067 | city | |
| 1068 | civic | |
| 1069 | civil | |
| 1070 | clad | |
| 1071 | claim | |
| 1072 | clambake | |
| 1073 | clammy | |
| 1074 | clamor | |
| 1075 | clamp | |
| 1076 | clamshell | |
| 1077 | clang | |
| 1078 | clanking | |
| 1079 | clapped | |
| 1080 | clapper | |
| 1081 | clapping | |
| 1082 | clarify | |
| 1083 | clarinet | |
| 1084 | clarity | |
| 1085 | clash | |
| 1086 | clasp | |
| 1087 | class | |
| 1088 | clatter | |
| 1089 | clause | |
| 1090 | clavicle | |
| 1091 | claw | |
| 1092 | clay | |
| 1093 | clean | |
| 1094 | clear | |
| 1095 | cleat | |
| 1096 | cleaver | |
| 1097 | cleft | |
| 1098 | clench | |
| 1099 | clergyman | |
| 1100 | clerical | |
| 1101 | clerk | |
| 1102 | clever | |
| 1103 | clicker | |
| 1104 | client | |
| 1105 | climate | |
| 1106 | climatic | |
| 1107 | cling | |
| 1108 | clinic | |
| 1109 | clinking | |
| 1110 | clip | |
| 1111 | clique | |
| 1112 | cloak | |
| 1113 | clobber | |
| 1114 | clock | |
| 1115 | clone | |
| 1116 | cloning | |
| 1117 | closable | |
| 1118 | closure | |
| 1119 | clothes | |
| 1120 | clothing | |
| 1121 | cloud | |
| 1122 | clover | |
| 1123 | clubbed | |
| 1124 | clubbing | |
| 1125 | clubhouse | |
| 1126 | clump | |
| 1127 | clumsily | |
| 1128 | clumsy | |
| 1129 | clunky | |
| 1130 | clustered | |
| 1131 | clutch | |
| 1132 | clutter | |
| 1133 | coach | |
| 1134 | coagulant | |
| 1135 | coastal | |
| 1136 | coaster | |
| 1137 | coasting | |
| 1138 | coastland | |
| 1139 | coastline | |
| 1140 | coat | |
| 1141 | coauthor | |
| 1142 | cobalt | |
| 1143 | cobbler | |
| 1144 | cobweb | |
| 1145 | cocoa | |
| 1146 | coconut | |
| 1147 | cod | |
| 1148 | coeditor | |
| 1149 | coerce | |
| 1150 | coexist | |
| 1151 | coffee | |
| 1152 | cofounder | |
| 1153 | cognition | |
| 1154 | cognitive | |
| 1155 | cogwheel | |
| 1156 | coherence | |
| 1157 | coherent | |
| 1158 | cohesive | |
| 1159 | coil | |
| 1160 | coke | |
| 1161 | cola | |
| 1162 | cold | |
| 1163 | coleslaw | |
| 1164 | coliseum | |
| 1165 | collage | |
| 1166 | collapse | |
| 1167 | collar | |
| 1168 | collected | |
| 1169 | collector | |
| 1170 | collide | |
| 1171 | collie | |
| 1172 | collision | |
| 1173 | colonial | |
| 1174 | colonist | |
| 1175 | colonize | |
| 1176 | colony | |
| 1177 | colossal | |
| 1178 | colt | |
| 1179 | coma | |
| 1180 | come | |
| 1181 | comfort | |
| 1182 | comfy | |
| 1183 | comic | |
| 1184 | coming | |
| 1185 | comma | |
| 1186 | commence | |
| 1187 | commend | |
| 1188 | comment | |
| 1189 | commerce | |
| 1190 | commode | |
| 1191 | commodity | |
| 1192 | commodore | |
| 1193 | common | |
| 1194 | commotion | |
| 1195 | commute | |
| 1196 | commuting | |
| 1197 | compacted | |
| 1198 | compacter | |
| 1199 | compactly | |
| 1200 | compactor | |
| 1201 | companion | |
| 1202 | company | |
| 1203 | compare | |
| 1204 | compel | |
| 1205 | compile | |
| 1206 | comply | |
| 1207 | component | |
| 1208 | composed | |
| 1209 | composer | |
| 1210 | composite | |
| 1211 | compost | |
| 1212 | composure | |
| 1213 | compound | |
| 1214 | compress | |
| 1215 | comprised | |
| 1216 | computer | |
| 1217 | computing | |
| 1218 | comrade | |
| 1219 | concave | |
| 1220 | conceal | |
| 1221 | conceded | |
| 1222 | concept | |
| 1223 | concerned | |
| 1224 | concert | |
| 1225 | conch | |
| 1226 | concierge | |
| 1227 | concise | |
| 1228 | conclude | |
| 1229 | concrete | |
| 1230 | concur | |
| 1231 | condense | |
| 1232 | condiment | |
| 1233 | condition | |
| 1234 | condone | |
| 1235 | conducive | |
| 1236 | conductor | |
| 1237 | conduit | |
| 1238 | cone | |
| 1239 | confess | |
| 1240 | confetti | |
| 1241 | confidant | |
| 1242 | confident | |
| 1243 | confider | |
| 1244 | confiding | |
| 1245 | configure | |
| 1246 | confined | |
| 1247 | confining | |
| 1248 | confirm | |
| 1249 | conflict | |
| 1250 | conform | |
| 1251 | confound | |
| 1252 | confront | |
| 1253 | confused | |
| 1254 | confusing | |
| 1255 | confusion | |
| 1256 | congenial | |
| 1257 | congested | |
| 1258 | congrats | |
| 1259 | congress | |
| 1260 | conical | |
| 1261 | conjoined | |
| 1262 | conjure | |
| 1263 | conjuror | |
| 1264 | connected | |
| 1265 | connector | |
| 1266 | consensus | |
| 1267 | consent | |
| 1268 | console | |
| 1269 | consoling | |
| 1270 | consonant | |
| 1271 | constable | |
| 1272 | constant | |
| 1273 | constrain | |
| 1274 | constrict | |
| 1275 | construct | |
| 1276 | consult | |
| 1277 | consumer | |
| 1278 | consuming | |
| 1279 | contact | |
| 1280 | container | |
| 1281 | contempt | |
| 1282 | contend | |
| 1283 | contented | |
| 1284 | contently | |
| 1285 | contents | |
| 1286 | contest | |
| 1287 | context | |
| 1288 | contort | |
| 1289 | contour | |
| 1290 | contrite | |
| 1291 | control | |
| 1292 | contusion | |
| 1293 | convene | |
| 1294 | convent | |
| 1295 | copartner | |
| 1296 | cope | |
| 1297 | copied | |
| 1298 | copier | |
| 1299 | copilot | |
| 1300 | coping | |
| 1301 | copious | |
| 1302 | copper | |
| 1303 | copy | |
| 1304 | coral | |
| 1305 | cork | |
| 1306 | cornball | |
| 1307 | cornbread | |
| 1308 | corncob | |
| 1309 | cornea | |
| 1310 | corned | |
| 1311 | corner | |
| 1312 | cornfield | |
| 1313 | cornflake | |
| 1314 | cornhusk | |
| 1315 | cornmeal | |
| 1316 | cornstalk | |
| 1317 | corny | |
| 1318 | coronary | |
| 1319 | coroner | |
| 1320 | corporal | |
| 1321 | corporate | |
| 1322 | corral | |
| 1323 | correct | |
| 1324 | corridor | |
| 1325 | corrode | |
| 1326 | corroding | |
| 1327 | corrosive | |
| 1328 | corsage | |
| 1329 | corset | |
| 1330 | cortex | |
| 1331 | cosigner | |
| 1332 | cosmetics | |
| 1333 | cosmic | |
| 1334 | cosmos | |
| 1335 | cosponsor | |
| 1336 | cost | |
| 1337 | cottage | |
| 1338 | cotton | |
| 1339 | couch | |
| 1340 | cough | |
| 1341 | could | |
| 1342 | countable | |
| 1343 | countdown | |
| 1344 | counting | |
| 1345 | countless | |
| 1346 | country | |
| 1347 | county | |
| 1348 | courier | |
| 1349 | covenant | |
| 1350 | cover | |
| 1351 | coveted | |
| 1352 | coveting | |
| 1353 | coyness | |
| 1354 | cozily | |
| 1355 | coziness | |
| 1356 | cozy | |
| 1357 | crabbing | |
| 1358 | crabgrass | |
| 1359 | crablike | |
| 1360 | crabmeat | |
| 1361 | cradle | |
| 1362 | cradling | |
| 1363 | crafter | |
| 1364 | craftily | |
| 1365 | craftsman | |
| 1366 | craftwork | |
| 1367 | crafty | |
| 1368 | cramp | |
| 1369 | cranberry | |
| 1370 | crane | |
| 1371 | cranial | |
| 1372 | cranium | |
| 1373 | crank | |
| 1374 | crate | |
| 1375 | crave | |
| 1376 | craving | |
| 1377 | crawfish | |
| 1378 | crawlers | |
| 1379 | crawling | |
| 1380 | crayfish | |
| 1381 | crayon | |
| 1382 | crazed | |
| 1383 | crazily | |
| 1384 | craziness | |
| 1385 | crazy | |
| 1386 | creamed | |
| 1387 | creamer | |
| 1388 | creamlike | |
| 1389 | crease | |
| 1390 | creasing | |
| 1391 | creatable | |
| 1392 | create | |
| 1393 | creation | |
| 1394 | creative | |
| 1395 | creature | |
| 1396 | credible | |
| 1397 | credibly | |
| 1398 | credit | |
| 1399 | creed | |
| 1400 | creme | |
| 1401 | creole | |
| 1402 | crepe | |
| 1403 | crept | |
| 1404 | crescent | |
| 1405 | crested | |
| 1406 | cresting | |
| 1407 | crestless | |
| 1408 | crevice | |
| 1409 | crewless | |
| 1410 | crewman | |
| 1411 | crewmate | |
| 1412 | crib | |
| 1413 | cricket | |
| 1414 | cried | |
| 1415 | crier | |
| 1416 | crimp | |
| 1417 | crimson | |
| 1418 | cringe | |
| 1419 | cringing | |
| 1420 | crinkle | |
| 1421 | crinkly | |
| 1422 | crisped | |
| 1423 | crisping | |
| 1424 | crisply | |
| 1425 | crispness | |
| 1426 | crispy | |
| 1427 | criteria | |
| 1428 | critter | |
| 1429 | croak | |
| 1430 | crock | |
| 1431 | crook | |
| 1432 | croon | |
| 1433 | crop | |
| 1434 | cross | |
| 1435 | crouch | |
| 1436 | crouton | |
| 1437 | crowbar | |
| 1438 | crowd | |
| 1439 | crown | |
| 1440 | crucial | |
| 1441 | crudely | |
| 1442 | crudeness | |
| 1443 | cruelly | |
| 1444 | cruelness | |
| 1445 | cruelty | |
| 1446 | crumb | |
| 1447 | crummiest | |
| 1448 | crummy | |
| 1449 | crumpet | |
| 1450 | crumpled | |
| 1451 | cruncher | |
| 1452 | crunching | |
| 1453 | crunchy | |
| 1454 | crusader | |
| 1455 | crushable | |
| 1456 | crushed | |
| 1457 | crusher | |
| 1458 | crushing | |
| 1459 | crust | |
| 1460 | crux | |
| 1461 | crying | |
| 1462 | cryptic | |
| 1463 | crystal | |
| 1464 | cubbyhole | |
| 1465 | cube | |
| 1466 | cubical | |
| 1467 | cubicle | |
| 1468 | cucumber | |
| 1469 | cuddle | |
| 1470 | cuddly | |
| 1471 | cufflink | |
| 1472 | culinary | |
| 1473 | culminate | |
| 1474 | culpable | |
| 1475 | culprit | |
| 1476 | cultivate | |
| 1477 | cultural | |
| 1478 | culture | |
| 1479 | cupbearer | |
| 1480 | cupcake | |
| 1481 | cupid | |
| 1482 | cupped | |
| 1483 | cupping | |
| 1484 | curable | |
| 1485 | curator | |
| 1486 | curdle | |
| 1487 | cure | |
| 1488 | curfew | |
| 1489 | curing | |
| 1490 | curled | |
| 1491 | curler | |
| 1492 | curliness | |
| 1493 | curling | |
| 1494 | curly | |
| 1495 | curry | |
| 1496 | curse | |
| 1497 | cursive | |
| 1498 | cursor | |
| 1499 | curtain | |
| 1500 | curtly | |
| 1501 | curtsy | |
| 1502 | curvature | |
| 1503 | curve | |
| 1504 | curvy | |
| 1505 | cushy | |
| 1506 | cusp | |
| 1507 | cussed | |
| 1508 | custard | |
| 1509 | custodian | |
| 1510 | custody | |
| 1511 | customary | |
| 1512 | customer | |
| 1513 | customize | |
| 1514 | customs | |
| 1515 | cut | |
| 1516 | cycle | |
| 1517 | cyclic | |
| 1518 | cycling | |
| 1519 | cyclist | |
| 1520 | cylinder | |
| 1521 | cymbal | |
| 1522 | cytoplasm | |
| 1523 | cytoplast | |
| 1524 | dab | |
| 1525 | dad | |
| 1526 | daffodil | |
| 1527 | dagger | |
| 1528 | daily | |
| 1529 | daintily | |
| 1530 | dainty | |
| 1531 | dairy | |
| 1532 | daisy | |
| 1533 | dallying | |
| 1534 | dance | |
| 1535 | dancing | |
| 1536 | dandelion | |
| 1537 | dander | |
| 1538 | dandruff | |
| 1539 | dandy | |
| 1540 | danger | |
| 1541 | dangle | |
| 1542 | dangling | |
| 1543 | daredevil | |
| 1544 | dares | |
| 1545 | daringly | |
| 1546 | darkened | |
| 1547 | darkening | |
| 1548 | darkish | |
| 1549 | darkness | |
| 1550 | darkroom | |
| 1551 | darling | |
| 1552 | darn | |
| 1553 | dart | |
| 1554 | darwinism | |
| 1555 | dash | |
| 1556 | dastardly | |
| 1557 | data | |
| 1558 | datebook | |
| 1559 | dating | |
| 1560 | daughter | |
| 1561 | daunting | |
| 1562 | dawdler | |
| 1563 | dawn | |
| 1564 | daybed | |
| 1565 | daybreak | |
| 1566 | daycare | |
| 1567 | daydream | |
| 1568 | daylight | |
| 1569 | daylong | |
| 1570 | dayroom | |
| 1571 | daytime | |
| 1572 | dazzler | |
| 1573 | dazzling | |
| 1574 | deacon | |
| 1575 | deafening | |
| 1576 | deafness | |
| 1577 | dealer | |
| 1578 | dealing | |
| 1579 | dealmaker | |
| 1580 | dealt | |
| 1581 | dean | |
| 1582 | debatable | |
| 1583 | debate | |
| 1584 | debating | |
| 1585 | debit | |
| 1586 | debrief | |
| 1587 | debtless | |
| 1588 | debtor | |
| 1589 | debug | |
| 1590 | debunk | |
| 1591 | decade | |
| 1592 | decaf | |
| 1593 | decal | |
| 1594 | decathlon | |
| 1595 | decay | |
| 1596 | deceased | |
| 1597 | deceit | |
| 1598 | deceiver | |
| 1599 | deceiving | |
| 1600 | december | |
| 1601 | decency | |
| 1602 | decent | |
| 1603 | deception | |
| 1604 | deceptive | |
| 1605 | decibel | |
| 1606 | decidable | |
| 1607 | decimal | |
| 1608 | decimeter | |
| 1609 | decipher | |
| 1610 | deck | |
| 1611 | declared | |
| 1612 | decline | |
| 1613 | decode | |
| 1614 | decompose | |
| 1615 | decorated | |
| 1616 | decorator | |
| 1617 | decoy | |
| 1618 | decrease | |
| 1619 | decree | |
| 1620 | dedicate | |
| 1621 | dedicator | |
| 1622 | deduce | |
| 1623 | deduct | |
| 1624 | deed | |
| 1625 | deem | |
| 1626 | deepen | |
| 1627 | deeply | |
| 1628 | deepness | |
| 1629 | deface | |
| 1630 | defacing | |
| 1631 | defame | |
| 1632 | default | |
| 1633 | defeat | |
| 1634 | defection | |
| 1635 | defective | |
| 1636 | defendant | |
| 1637 | defender | |
| 1638 | defense | |
| 1639 | defensive | |
| 1640 | deferral | |
| 1641 | deferred | |
| 1642 | defiance | |
| 1643 | defiant | |
| 1644 | defile | |
| 1645 | defiling | |
| 1646 | define | |
| 1647 | definite | |
| 1648 | deflate | |
| 1649 | deflation | |
| 1650 | deflator | |
| 1651 | deflected | |
| 1652 | deflector | |
| 1653 | defog | |
| 1654 | deforest | |
| 1655 | defraud | |
| 1656 | defrost | |
| 1657 | deftly | |
| 1658 | defuse | |
| 1659 | defy | |
| 1660 | degraded | |
| 1661 | degrading | |
| 1662 | degrease | |
| 1663 | degree | |
| 1664 | dehydrate | |
| 1665 | deity | |
| 1666 | dejected | |
| 1667 | delay | |
| 1668 | delegate | |
| 1669 | delegator | |
| 1670 | delete | |
| 1671 | deletion | |
| 1672 | delicacy | |
| 1673 | delicate | |
| 1674 | delicious | |
| 1675 | delighted | |
| 1676 | delirious | |
| 1677 | delirium | |
| 1678 | deliverer | |
| 1679 | delivery | |
| 1680 | delouse | |
| 1681 | delta | |
| 1682 | deluge | |
| 1683 | delusion | |
| 1684 | deluxe | |
| 1685 | demanding | |
| 1686 | demeaning | |
| 1687 | demeanor | |
| 1688 | demise | |
| 1689 | democracy | |
| 1690 | democrat | |
| 1691 | demote | |
| 1692 | demotion | |
| 1693 | demystify | |
| 1694 | denatured | |
| 1695 | deniable | |
| 1696 | denial | |
| 1697 | denim | |
| 1698 | denote | |
| 1699 | dense | |
| 1700 | density | |
| 1701 | dental | |
| 1702 | dentist | |
| 1703 | denture | |
| 1704 | deny | |
| 1705 | deodorant | |
| 1706 | deodorize | |
| 1707 | departed | |
| 1708 | departure | |
| 1709 | depict | |
| 1710 | deplete | |
| 1711 | depletion | |
| 1712 | deplored | |
| 1713 | deploy | |
| 1714 | deport | |
| 1715 | depose | |
| 1716 | depraved | |
| 1717 | depravity | |
| 1718 | deprecate | |
| 1719 | depress | |
| 1720 | deprive | |
| 1721 | depth | |
| 1722 | deputize | |
| 1723 | deputy | |
| 1724 | derail | |
| 1725 | deranged | |
| 1726 | derby | |
| 1727 | derived | |
| 1728 | desecrate | |
| 1729 | deserve | |
| 1730 | deserving | |
| 1731 | designate | |
| 1732 | designed | |
| 1733 | designer | |
| 1734 | designing | |
| 1735 | deskbound | |
| 1736 | desktop | |
| 1737 | deskwork | |
| 1738 | desolate | |
| 1739 | despair | |
| 1740 | despise | |
| 1741 | despite | |
| 1742 | destiny | |
| 1743 | destitute | |
| 1744 | destruct | |
| 1745 | detached | |
| 1746 | detail | |
| 1747 | detection | |
| 1748 | detective | |
| 1749 | detector | |
| 1750 | detention | |
| 1751 | detergent | |
| 1752 | detest | |
| 1753 | detonate | |
| 1754 | detonator | |
| 1755 | detoxify | |
| 1756 | detract | |
| 1757 | deuce | |
| 1758 | devalue | |
| 1759 | deviancy | |
| 1760 | deviant | |
| 1761 | deviate | |
| 1762 | deviation | |
| 1763 | deviator | |
| 1764 | device | |
| 1765 | devious | |
| 1766 | devotedly | |
| 1767 | devotee | |
| 1768 | devotion | |
| 1769 | devourer | |
| 1770 | devouring | |
| 1771 | devoutly | |
| 1772 | dexterity | |
| 1773 | dexterous | |
| 1774 | diabetes | |
| 1775 | diabetic | |
| 1776 | diabolic | |
| 1777 | diagnoses | |
| 1778 | diagnosis | |
| 1779 | diagram | |
| 1780 | dial | |
| 1781 | diameter | |
| 1782 | diaper | |
| 1783 | diaphragm | |
| 1784 | diary | |
| 1785 | dice | |
| 1786 | dicing | |
| 1787 | dictate | |
| 1788 | dictation | |
| 1789 | dictator | |
| 1790 | difficult | |
| 1791 | diffused | |
| 1792 | diffuser | |
| 1793 | diffusion | |
| 1794 | diffusive | |
| 1795 | dig | |
| 1796 | dilation | |
| 1797 | diligence | |
| 1798 | diligent | |
| 1799 | dill | |
| 1800 | dilute | |
| 1801 | dime | |
| 1802 | diminish | |
| 1803 | dimly | |
| 1804 | dimmed | |
| 1805 | dimmer | |
| 1806 | dimness | |
| 1807 | dimple | |
| 1808 | diner | |
| 1809 | dingbat | |
| 1810 | dinghy | |
| 1811 | dinginess | |
| 1812 | dingo | |
| 1813 | dingy | |
| 1814 | dining | |
| 1815 | dinner | |
| 1816 | diocese | |
| 1817 | dioxide | |
| 1818 | diploma | |
| 1819 | dipped | |
| 1820 | dipper | |
| 1821 | dipping | |
| 1822 | directed | |
| 1823 | direction | |
| 1824 | directive | |
| 1825 | directly | |
| 1826 | directory | |
| 1827 | direness | |
| 1828 | dirtiness | |
| 1829 | disabled | |
| 1830 | disagree | |
| 1831 | disallow | |
| 1832 | disarm | |
| 1833 | disarray | |
| 1834 | disaster | |
| 1835 | disband | |
| 1836 | disbelief | |
| 1837 | disburse | |
| 1838 | discard | |
| 1839 | discern | |
| 1840 | discharge | |
| 1841 | disclose | |
| 1842 | discolor | |
| 1843 | discount | |
| 1844 | discourse | |
| 1845 | discover | |
| 1846 | discuss | |
| 1847 | disdain | |
| 1848 | disengage | |
| 1849 | disfigure | |
| 1850 | disgrace | |
| 1851 | dish | |
| 1852 | disinfect | |
| 1853 | disjoin | |
| 1854 | disk | |
| 1855 | dislike | |
| 1856 | disliking | |
| 1857 | dislocate | |
| 1858 | dislodge | |
| 1859 | disloyal | |
| 1860 | dismantle | |
| 1861 | dismay | |
| 1862 | dismiss | |
| 1863 | dismount | |
| 1864 | disobey | |
| 1865 | disorder | |
| 1866 | disown | |
| 1867 | disparate | |
| 1868 | disparity | |
| 1869 | dispatch | |
| 1870 | dispense | |
| 1871 | dispersal | |
| 1872 | dispersed | |
| 1873 | disperser | |
| 1874 | displace | |
| 1875 | display | |
| 1876 | displease | |
| 1877 | disposal | |
| 1878 | dispose | |
| 1879 | disprove | |
| 1880 | dispute | |
| 1881 | disregard | |
| 1882 | disrupt | |
| 1883 | dissuade | |
| 1884 | distance | |
| 1885 | distant | |
| 1886 | distaste | |
| 1887 | distill | |
| 1888 | distinct | |
| 1889 | distort | |
| 1890 | distract | |
| 1891 | distress | |
| 1892 | district | |
| 1893 | distrust | |
| 1894 | ditch | |
| 1895 | ditto | |
| 1896 | ditzy | |
| 1897 | dividable | |
| 1898 | divided | |
| 1899 | dividend | |
| 1900 | dividers | |
| 1901 | dividing | |
| 1902 | divinely | |
| 1903 | diving | |
| 1904 | divinity | |
| 1905 | divisible | |
| 1906 | divisibly | |
| 1907 | division | |
| 1908 | divisive | |
| 1909 | divorcee | |
| 1910 | dizziness | |
| 1911 | dizzy | |
| 1912 | doable | |
| 1913 | docile | |
| 1914 | dock | |
| 1915 | doctrine | |
| 1916 | document | |
| 1917 | dodge | |
| 1918 | dodgy | |
| 1919 | doily | |
| 1920 | doing | |
| 1921 | dole | |
| 1922 | dollar | |
| 1923 | dollhouse | |
| 1924 | dollop | |
| 1925 | dolly | |
| 1926 | dolphin | |
| 1927 | domain | |
| 1928 | domelike | |
| 1929 | domestic | |
| 1930 | dominion | |
| 1931 | dominoes | |
| 1932 | donated | |
| 1933 | donation | |
| 1934 | donator | |
| 1935 | donor | |
| 1936 | donut | |
| 1937 | doodle | |
| 1938 | doorbell | |
| 1939 | doorframe | |
| 1940 | doorknob | |
| 1941 | doorman | |
| 1942 | doormat | |
| 1943 | doornail | |
| 1944 | doorpost | |
| 1945 | doorstep | |
| 1946 | doorstop | |
| 1947 | doorway | |
| 1948 | doozy | |
| 1949 | dork | |
| 1950 | dormitory | |
| 1951 | dorsal | |
| 1952 | dosage | |
| 1953 | dose | |
| 1954 | dotted | |
| 1955 | doubling | |
| 1956 | douche | |
| 1957 | dove | |
| 1958 | down | |
| 1959 | dowry | |
| 1960 | doze | |
| 1961 | drab | |
| 1962 | dragging | |
| 1963 | dragonfly | |
| 1964 | dragonish | |
| 1965 | dragster | |
| 1966 | drainable | |
| 1967 | drainage | |
| 1968 | drained | |
| 1969 | drainer | |
| 1970 | drainpipe | |
| 1971 | dramatic | |
| 1972 | dramatize | |
| 1973 | drank | |
| 1974 | drapery | |
| 1975 | drastic | |
| 1976 | draw | |
| 1977 | dreaded | |
| 1978 | dreadful | |
| 1979 | dreadlock | |
| 1980 | dreamboat | |
| 1981 | dreamily | |
| 1982 | dreamland | |
| 1983 | dreamless | |
| 1984 | dreamlike | |
| 1985 | dreamt | |
| 1986 | dreamy | |
| 1987 | drearily | |
| 1988 | dreary | |
| 1989 | drench | |
| 1990 | dress | |
| 1991 | drew | |
| 1992 | dribble | |
| 1993 | dried | |
| 1994 | drier | |
| 1995 | drift | |
| 1996 | driller | |
| 1997 | drilling | |
| 1998 | drinkable | |
| 1999 | drinking | |
| 2000 | dripping | |
| 2001 | drippy | |
| 2002 | drivable | |
| 2003 | driven | |
| 2004 | driver | |
| 2005 | driveway | |
| 2006 | driving | |
| 2007 | drizzle | |
| 2008 | drizzly | |
| 2009 | drone | |
| 2010 | drool | |
| 2011 | droop | |
| 2012 | drop-down | |
| 2013 | dropbox | |
| 2014 | dropkick | |
| 2015 | droplet | |
| 2016 | dropout | |
| 2017 | dropper | |
| 2018 | drove | |
| 2019 | drown | |
| 2020 | drowsily | |
| 2021 | drudge | |
| 2022 | drum | |
| 2023 | dry | |
| 2024 | dubbed | |
| 2025 | dubiously | |
| 2026 | duchess | |
| 2027 | duckbill | |
| 2028 | ducking | |
| 2029 | duckling | |
| 2030 | ducktail | |
| 2031 | ducky | |
| 2032 | duct | |
| 2033 | dude | |
| 2034 | duffel | |
| 2035 | dugout | |
| 2036 | duh | |
| 2037 | duke | |
| 2038 | duller | |
| 2039 | dullness | |
| 2040 | duly | |
| 2041 | dumping | |
| 2042 | dumpling | |
| 2043 | dumpster | |
| 2044 | duo | |
| 2045 | dupe | |
| 2046 | duplex | |
| 2047 | duplicate | |
| 2048 | duplicity | |
| 2049 | durable | |
| 2050 | durably | |
| 2051 | duration | |
| 2052 | duress | |
| 2053 | during | |
| 2054 | dusk | |
| 2055 | dust | |
| 2056 | dutiful | |
| 2057 | duty | |
| 2058 | duvet | |
| 2059 | dwarf | |
| 2060 | dweeb | |
| 2061 | dwelled | |
| 2062 | dweller | |
| 2063 | dwelling | |
| 2064 | dwindle | |
| 2065 | dwindling | |
| 2066 | dynamic | |
| 2067 | dynamite | |
| 2068 | dynasty | |
| 2069 | dyslexia | |
| 2070 | dyslexic | |
| 2071 | each | |
| 2072 | eagle | |
| 2073 | earache | |
| 2074 | eardrum | |
| 2075 | earflap | |
| 2076 | earful | |
| 2077 | earlobe | |
| 2078 | early | |
| 2079 | earmark | |
| 2080 | earmuff | |
| 2081 | earphone | |
| 2082 | earpiece | |
| 2083 | earplugs | |
| 2084 | earring | |
| 2085 | earshot | |
| 2086 | earthen | |
| 2087 | earthlike | |
| 2088 | earthling | |
| 2089 | earthly | |
| 2090 | earthworm | |
| 2091 | earthy | |
| 2092 | earwig | |
| 2093 | easeful | |
| 2094 | easel | |
| 2095 | easiest | |
| 2096 | easily | |
| 2097 | easiness | |
| 2098 | easing | |
| 2099 | eastbound | |
| 2100 | eastcoast | |
| 2101 | easter | |
| 2102 | eastward | |
| 2103 | eatable | |
| 2104 | eaten | |
| 2105 | eatery | |
| 2106 | eating | |
| 2107 | eats | |
| 2108 | ebay | |
| 2109 | ebony | |
| 2110 | ebook | |
| 2111 | ecard | |
| 2112 | eccentric | |
| 2113 | echo | |
| 2114 | eclair | |
| 2115 | eclipse | |
| 2116 | ecologist | |
| 2117 | ecology | |
| 2118 | economic | |
| 2119 | economist | |
| 2120 | economy | |
| 2121 | ecosphere | |
| 2122 | ecosystem | |
| 2123 | edge | |
| 2124 | edginess | |
| 2125 | edging | |
| 2126 | edgy | |
| 2127 | edition | |
| 2128 | editor | |
| 2129 | educated | |
| 2130 | education | |
| 2131 | educator | |
| 2132 | eel | |
| 2133 | effective | |
| 2134 | effects | |
| 2135 | efficient | |
| 2136 | effort | |
| 2137 | eggbeater | |
| 2138 | egging | |
| 2139 | eggnog | |
| 2140 | eggplant | |
| 2141 | eggshell | |
| 2142 | egomaniac | |
| 2143 | egotism | |
| 2144 | egotistic | |
| 2145 | either | |
| 2146 | eject | |
| 2147 | elaborate | |
| 2148 | elastic | |
| 2149 | elated | |
| 2150 | elbow | |
| 2151 | eldercare | |
| 2152 | elderly | |
| 2153 | eldest | |
| 2154 | electable | |
| 2155 | election | |
| 2156 | elective | |
| 2157 | elephant | |
| 2158 | elevate | |
| 2159 | elevating | |
| 2160 | elevation | |
| 2161 | elevator | |
| 2162 | eleven | |
| 2163 | elf | |
| 2164 | eligible | |
| 2165 | eligibly | |
| 2166 | eliminate | |
| 2167 | elite | |
| 2168 | elitism | |
| 2169 | elixir | |
| 2170 | elk | |
| 2171 | ellipse | |
| 2172 | elliptic | |
| 2173 | elm | |
| 2174 | elongated | |
| 2175 | elope | |
| 2176 | eloquence | |
| 2177 | eloquent | |
| 2178 | elsewhere | |
| 2179 | elude | |
| 2180 | elusive | |
| 2181 | elves | |
| 2182 | ||
| 2183 | embargo | |
| 2184 | embark | |
| 2185 | embassy | |
| 2186 | embattled | |
| 2187 | embellish | |
| 2188 | ember | |
| 2189 | embezzle | |
| 2190 | emblaze | |
| 2191 | emblem | |
| 2192 | embody | |
| 2193 | embolism | |
| 2194 | emboss | |
| 2195 | embroider | |
| 2196 | emcee | |
| 2197 | emerald | |
| 2198 | emergency | |
| 2199 | emission | |
| 2200 | emit | |
| 2201 | emote | |
| 2202 | emoticon | |
| 2203 | emotion | |
| 2204 | empathic | |
| 2205 | empathy | |
| 2206 | emperor | |
| 2207 | emphases | |
| 2208 | emphasis | |
| 2209 | emphasize | |
| 2210 | emphatic | |
| 2211 | empirical | |
| 2212 | employed | |
| 2213 | employee | |
| 2214 | employer | |
| 2215 | emporium | |
| 2216 | empower | |
| 2217 | emptier | |
| 2218 | emptiness | |
| 2219 | empty | |
| 2220 | emu | |
| 2221 | enable | |
| 2222 | enactment | |
| 2223 | enamel | |
| 2224 | enchanted | |
| 2225 | enchilada | |
| 2226 | encircle | |
| 2227 | enclose | |
| 2228 | enclosure | |
| 2229 | encode | |
| 2230 | encore | |
| 2231 | encounter | |
| 2232 | encourage | |
| 2233 | encroach | |
| 2234 | encrust | |
| 2235 | encrypt | |
| 2236 | endanger | |
| 2237 | endeared | |
| 2238 | endearing | |
| 2239 | ended | |
| 2240 | ending | |
| 2241 | endless | |
| 2242 | endnote | |
| 2243 | endocrine | |
| 2244 | endorphin | |
| 2245 | endorse | |
| 2246 | endowment | |
| 2247 | endpoint | |
| 2248 | endurable | |
| 2249 | endurance | |
| 2250 | enduring | |
| 2251 | energetic | |
| 2252 | energize | |
| 2253 | energy | |
| 2254 | enforced | |
| 2255 | enforcer | |
| 2256 | engaged | |
| 2257 | engaging | |
| 2258 | engine | |
| 2259 | engorge | |
| 2260 | engraved | |
| 2261 | engraver | |
| 2262 | engraving | |
| 2263 | engross | |
| 2264 | engulf | |
| 2265 | enhance | |
| 2266 | enigmatic | |
| 2267 | enjoyable | |
| 2268 | enjoyably | |
| 2269 | enjoyer | |
| 2270 | enjoying | |
| 2271 | enjoyment | |
| 2272 | enlarged | |
| 2273 | enlarging | |
| 2274 | enlighten | |
| 2275 | enlisted | |
| 2276 | enquirer | |
| 2277 | enrage | |
| 2278 | enrich | |
| 2279 | enroll | |
| 2280 | enslave | |
| 2281 | ensnare | |
| 2282 | ensure | |
| 2283 | entail | |
| 2284 | entangled | |
| 2285 | entering | |
| 2286 | entertain | |
| 2287 | enticing | |
| 2288 | entire | |
| 2289 | entitle | |
| 2290 | entity | |
| 2291 | entomb | |
| 2292 | entourage | |
| 2293 | entrap | |
| 2294 | entree | |
| 2295 | entrench | |
| 2296 | entrust | |
| 2297 | entryway | |
| 2298 | entwine | |
| 2299 | enunciate | |
| 2300 | envelope | |
| 2301 | enviable | |
| 2302 | enviably | |
| 2303 | envious | |
| 2304 | envision | |
| 2305 | envoy | |
| 2306 | envy | |
| 2307 | enzyme | |
| 2308 | epic | |
| 2309 | epidemic | |
| 2310 | epidermal | |
| 2311 | epidermis | |
| 2312 | epidural | |
| 2313 | epilepsy | |
| 2314 | epileptic | |
| 2315 | epilogue | |
| 2316 | epiphany | |
| 2317 | episode | |
| 2318 | equal | |
| 2319 | equate | |
| 2320 | equation | |
| 2321 | equator | |
| 2322 | equinox | |
| 2323 | equipment | |
| 2324 | equity | |
| 2325 | equivocal | |
| 2326 | eradicate | |
| 2327 | erasable | |
| 2328 | erased | |
| 2329 | eraser | |
| 2330 | erasure | |
| 2331 | ergonomic | |
| 2332 | errand | |
| 2333 | errant | |
| 2334 | erratic | |
| 2335 | error | |
| 2336 | erupt | |
| 2337 | escalate | |
| 2338 | escalator | |
| 2339 | escapable | |
| 2340 | escapade | |
| 2341 | escapist | |
| 2342 | escargot | |
| 2343 | eskimo | |
| 2344 | esophagus | |
| 2345 | espionage | |
| 2346 | espresso | |
| 2347 | esquire | |
| 2348 | essay | |
| 2349 | essence | |
| 2350 | essential | |
| 2351 | establish | |
| 2352 | estate | |
| 2353 | esteemed | |
| 2354 | estimate | |
| 2355 | estimator | |
| 2356 | estranged | |
| 2357 | estrogen | |
| 2358 | etching | |
| 2359 | eternal | |
| 2360 | eternity | |
| 2361 | ethanol | |
| 2362 | ether | |
| 2363 | ethically | |
| 2364 | ethics | |
| 2365 | euphemism | |
| 2366 | evacuate | |
| 2367 | evacuee | |
| 2368 | evade | |
| 2369 | evaluate | |
| 2370 | evaluator | |
| 2371 | evaporate | |
| 2372 | evasion | |
| 2373 | evasive | |
| 2374 | even | |
| 2375 | everglade | |
| 2376 | evergreen | |
| 2377 | everybody | |
| 2378 | everyday | |
| 2379 | everyone | |
| 2380 | evict | |
| 2381 | evidence | |
| 2382 | evident | |
| 2383 | evil | |
| 2384 | evoke | |
| 2385 | evolution | |
| 2386 | evolve | |
| 2387 | exact | |
| 2388 | exalted | |
| 2389 | example | |
| 2390 | excavate | |
| 2391 | excavator | |
| 2392 | exceeding | |
| 2393 | exception | |
| 2394 | excess | |
| 2395 | exchange | |
| 2396 | excitable | |
| 2397 | exciting | |
| 2398 | exclaim | |
| 2399 | exclude | |
| 2400 | excluding | |
| 2401 | exclusion | |
| 2402 | exclusive | |
| 2403 | excretion | |
| 2404 | excretory | |
| 2405 | excursion | |
| 2406 | excusable | |
| 2407 | excusably | |
| 2408 | excuse | |
| 2409 | exemplary | |
| 2410 | exemplify | |
| 2411 | exemption | |
| 2412 | exerciser | |
| 2413 | exert | |
| 2414 | exes | |
| 2415 | exfoliate | |
| 2416 | exhale | |
| 2417 | exhaust | |
| 2418 | exhume | |
| 2419 | exile | |
| 2420 | existing | |
| 2421 | exit | |
| 2422 | exodus | |
| 2423 | exonerate | |
| 2424 | exorcism | |
| 2425 | exorcist | |
| 2426 | expand | |
| 2427 | expanse | |
| 2428 | expansion | |
| 2429 | expansive | |
| 2430 | expectant | |
| 2431 | expedited | |
| 2432 | expediter | |
| 2433 | expel | |
| 2434 | expend | |
| 2435 | expenses | |
| 2436 | expensive | |
| 2437 | expert | |
| 2438 | expire | |
| 2439 | expiring | |
| 2440 | explain | |
| 2441 | expletive | |
| 2442 | explicit | |
| 2443 | explode | |
| 2444 | exploit | |
| 2445 | explore | |
| 2446 | exploring | |
| 2447 | exponent | |
| 2448 | exporter | |
| 2449 | exposable | |
| 2450 | expose | |
| 2451 | exposure | |
| 2452 | express | |
| 2453 | expulsion | |
| 2454 | exquisite | |
| 2455 | extended | |
| 2456 | extending | |
| 2457 | extent | |
| 2458 | extenuate | |
| 2459 | exterior | |
| 2460 | external | |
| 2461 | extinct | |
| 2462 | extortion | |
| 2463 | extradite | |
| 2464 | extras | |
| 2465 | extrovert | |
| 2466 | extrude | |
| 2467 | extruding | |
| 2468 | exuberant | |
| 2469 | fable | |
| 2470 | fabric | |
| 2471 | fabulous | |
| 2472 | ||
| 2473 | facecloth | |
| 2474 | facedown | |
| 2475 | faceless | |
| 2476 | facelift | |
| 2477 | faceplate | |
| 2478 | faceted | |
| 2479 | facial | |
| 2480 | facility | |
| 2481 | facing | |
| 2482 | facsimile | |
| 2483 | faction | |
| 2484 | factoid | |
| 2485 | factor | |
| 2486 | factsheet | |
| 2487 | factual | |
| 2488 | faculty | |
| 2489 | fade | |
| 2490 | fading | |
| 2491 | failing | |
| 2492 | falcon | |
| 2493 | fall | |
| 2494 | false | |
| 2495 | falsify | |
| 2496 | fame | |
| 2497 | familiar | |
| 2498 | family | |
| 2499 | famine | |
| 2500 | famished | |
| 2501 | fanatic | |
| 2502 | fancied | |
| 2503 | fanciness | |
| 2504 | fancy | |
| 2505 | fanfare | |
| 2506 | fang | |
| 2507 | fanning | |
| 2508 | fantasize | |
| 2509 | fantastic | |
| 2510 | fantasy | |
| 2511 | fascism | |
| 2512 | fastball | |
| 2513 | faster | |
| 2514 | fasting | |
| 2515 | fastness | |
| 2516 | faucet | |
| 2517 | favorable | |
| 2518 | favorably | |
| 2519 | favored | |
| 2520 | favoring | |
| 2521 | favorite | |
| 2522 | fax | |
| 2523 | feast | |
| 2524 | federal | |
| 2525 | fedora | |
| 2526 | feeble | |
| 2527 | feed | |
| 2528 | feel | |
| 2529 | feisty | |
| 2530 | feline | |
| 2531 | felt-tip | |
| 2532 | feminine | |
| 2533 | feminism | |
| 2534 | feminist | |
| 2535 | feminize | |
| 2536 | femur | |
| 2537 | fence | |
| 2538 | fencing | |
| 2539 | fender | |
| 2540 | ferment | |
| 2541 | fernlike | |
| 2542 | ferocious | |
| 2543 | ferocity | |
| 2544 | ferret | |
| 2545 | ferris | |
| 2546 | ferry | |
| 2547 | fervor | |
| 2548 | fester | |
| 2549 | festival | |
| 2550 | festive | |
| 2551 | festivity | |
| 2552 | fetal | |
| 2553 | fetch | |
| 2554 | fever | |
| 2555 | fiber | |
| 2556 | fiction | |
| 2557 | fiddle | |
| 2558 | fiddling | |
| 2559 | fidelity | |
| 2560 | fidgeting | |
| 2561 | fidgety | |
| 2562 | fifteen | |
| 2563 | fifth | |
| 2564 | fiftieth | |
| 2565 | fifty | |
| 2566 | figment | |
| 2567 | figure | |
| 2568 | figurine | |
| 2569 | filing | |
| 2570 | filled | |
| 2571 | filler | |
| 2572 | filling | |
| 2573 | film | |
| 2574 | filter | |
| 2575 | filth | |
| 2576 | filtrate | |
| 2577 | finale | |
| 2578 | finalist | |
| 2579 | finalize | |
| 2580 | finally | |
| 2581 | finance | |
| 2582 | financial | |
| 2583 | finch | |
| 2584 | fineness | |
| 2585 | finer | |
| 2586 | finicky | |
| 2587 | finished | |
| 2588 | finisher | |
| 2589 | finishing | |
| 2590 | finite | |
| 2591 | finless | |
| 2592 | finlike | |
| 2593 | fiscally | |
| 2594 | fit | |
| 2595 | five | |
| 2596 | flaccid | |
| 2597 | flagman | |
| 2598 | flagpole | |
| 2599 | flagship | |
| 2600 | flagstick | |
| 2601 | flagstone | |
| 2602 | flail | |
| 2603 | flakily | |
| 2604 | flaky | |
| 2605 | flame | |
| 2606 | flammable | |
| 2607 | flanked | |
| 2608 | flanking | |
| 2609 | flannels | |
| 2610 | flap | |
| 2611 | flaring | |
| 2612 | flashback | |
| 2613 | flashbulb | |
| 2614 | flashcard | |
| 2615 | flashily | |
| 2616 | flashing | |
| 2617 | flashy | |
| 2618 | flask | |
| 2619 | flatbed | |
| 2620 | flatfoot | |
| 2621 | flatly | |
| 2622 | flatness | |
| 2623 | flatten | |
| 2624 | flattered | |
| 2625 | flatterer | |
| 2626 | flattery | |
| 2627 | flattop | |
| 2628 | flatware | |
| 2629 | flatworm | |
| 2630 | flavored | |
| 2631 | flavorful | |
| 2632 | flavoring | |
| 2633 | flaxseed | |
| 2634 | fled | |
| 2635 | fleshed | |
| 2636 | fleshy | |
| 2637 | flick | |
| 2638 | flier | |
| 2639 | flight | |
| 2640 | flinch | |
| 2641 | fling | |
| 2642 | flint | |
| 2643 | flip | |
| 2644 | flirt | |
| 2645 | float | |
| 2646 | flock | |
| 2647 | flogging | |
| 2648 | flop | |
| 2649 | floral | |
| 2650 | florist | |
| 2651 | floss | |
| 2652 | flounder | |
| 2653 | flyable | |
| 2654 | flyaway | |
| 2655 | flyer | |
| 2656 | flying | |
| 2657 | flyover | |
| 2658 | flypaper | |
| 2659 | foam | |
| 2660 | foe | |
| 2661 | fog | |
| 2662 | foil | |
| 2663 | folic | |
| 2664 | folk | |
| 2665 | follicle | |
| 2666 | follow | |
| 2667 | fondling | |
| 2668 | fondly | |
| 2669 | fondness | |
| 2670 | fondue | |
| 2671 | font | |
| 2672 | food | |
| 2673 | fool | |
| 2674 | footage | |
| 2675 | football | |
| 2676 | footbath | |
| 2677 | footboard | |
| 2678 | footer | |
| 2679 | footgear | |
| 2680 | foothill | |
| 2681 | foothold | |
| 2682 | footing | |
| 2683 | footless | |
| 2684 | footman | |
| 2685 | footnote | |
| 2686 | footpad | |
| 2687 | footpath | |
| 2688 | footprint | |
| 2689 | footrest | |
| 2690 | footsie | |
| 2691 | footsore | |
| 2692 | footwear | |
| 2693 | footwork | |
| 2694 | fossil | |
| 2695 | foster | |
| 2696 | founder | |
| 2697 | founding | |
| 2698 | fountain | |
| 2699 | fox | |
| 2700 | foyer | |
| 2701 | fraction | |
| 2702 | fracture | |
| 2703 | fragile | |
| 2704 | fragility | |
| 2705 | fragment | |
| 2706 | fragrance | |
| 2707 | fragrant | |
| 2708 | frail | |
| 2709 | frame | |
| 2710 | framing | |
| 2711 | frantic | |
| 2712 | fraternal | |
| 2713 | frayed | |
| 2714 | fraying | |
| 2715 | frays | |
| 2716 | freckled | |
| 2717 | freckles | |
| 2718 | freebase | |
| 2719 | freebee | |
| 2720 | freebie | |
| 2721 | freedom | |
| 2722 | freefall | |
| 2723 | freehand | |
| 2724 | freeing | |
| 2725 | freeload | |
| 2726 | freely | |
| 2727 | freemason | |
| 2728 | freeness | |
| 2729 | freestyle | |
| 2730 | freeware | |
| 2731 | freeway | |
| 2732 | freewill | |
| 2733 | freezable | |
| 2734 | freezing | |
| 2735 | freight | |
| 2736 | french | |
| 2737 | frenzied | |
| 2738 | frenzy | |
| 2739 | frequency | |
| 2740 | frequent | |
| 2741 | fresh | |
| 2742 | fretful | |
| 2743 | fretted | |
| 2744 | friction | |
| 2745 | friday | |
| 2746 | fridge | |
| 2747 | fried | |
| 2748 | friend | |
| 2749 | frighten | |
| 2750 | frightful | |
| 2751 | frigidity | |
| 2752 | frigidly | |
| 2753 | frill | |
| 2754 | fringe | |
| 2755 | frisbee | |
| 2756 | frisk | |
| 2757 | fritter | |
| 2758 | frivolous | |
| 2759 | frolic | |
| 2760 | from | |
| 2761 | front | |
| 2762 | frostbite | |
| 2763 | frosted | |
| 2764 | frostily | |
| 2765 | frosting | |
| 2766 | frostlike | |
| 2767 | frosty | |
| 2768 | froth | |
| 2769 | frown | |
| 2770 | frozen | |
| 2771 | fructose | |
| 2772 | frugality | |
| 2773 | frugally | |
| 2774 | fruit | |
| 2775 | frustrate | |
| 2776 | frying | |
| 2777 | gab | |
| 2778 | gaffe | |
| 2779 | gag | |
| 2780 | gainfully | |
| 2781 | gaining | |
| 2782 | gains | |
| 2783 | gala | |
| 2784 | gallantly | |
| 2785 | galleria | |
| 2786 | gallery | |
| 2787 | galley | |
| 2788 | gallon | |
| 2789 | gallows | |
| 2790 | gallstone | |
| 2791 | galore | |
| 2792 | galvanize | |
| 2793 | gambling | |
| 2794 | game | |
| 2795 | gaming | |
| 2796 | gamma | |
| 2797 | gander | |
| 2798 | gangly | |
| 2799 | gangrene | |
| 2800 | gangway | |
| 2801 | gap | |
| 2802 | garage | |
| 2803 | garbage | |
| 2804 | garden | |
| 2805 | gargle | |
| 2806 | garland | |
| 2807 | garlic | |
| 2808 | garment | |
| 2809 | garnet | |
| 2810 | garnish | |
| 2811 | garter | |
| 2812 | gas | |
| 2813 | gatherer | |
| 2814 | gathering | |
| 2815 | gating | |
| 2816 | gauging | |
| 2817 | gauntlet | |
| 2818 | gauze | |
| 2819 | gave | |
| 2820 | gawk | |
| 2821 | gazing | |
| 2822 | gear | |
| 2823 | gecko | |
| 2824 | geek | |
| 2825 | geiger | |
| 2826 | gem | |
| 2827 | gender | |
| 2828 | generic | |
| 2829 | generous | |
| 2830 | genetics | |
| 2831 | genre | |
| 2832 | gentile | |
| 2833 | gentleman | |
| 2834 | gently | |
| 2835 | gents | |
| 2836 | geography | |
| 2837 | geologic | |
| 2838 | geologist | |
| 2839 | geology | |
| 2840 | geometric | |
| 2841 | geometry | |
| 2842 | geranium | |
| 2843 | gerbil | |
| 2844 | geriatric | |
| 2845 | germicide | |
| 2846 | germinate | |
| 2847 | germless | |
| 2848 | germproof | |
| 2849 | gestate | |
| 2850 | gestation | |
| 2851 | gesture | |
| 2852 | getaway | |
| 2853 | getting | |
| 2854 | getup | |
| 2855 | giant | |
| 2856 | gibberish | |
| 2857 | giblet | |
| 2858 | giddily | |
| 2859 | giddiness | |
| 2860 | giddy | |
| 2861 | gift | |
| 2862 | gigabyte | |
| 2863 | gigahertz | |
| 2864 | gigantic | |
| 2865 | giggle | |
| 2866 | giggling | |
| 2867 | giggly | |
| 2868 | gigolo | |
| 2869 | gilled | |
| 2870 | gills | |
| 2871 | gimmick | |
| 2872 | girdle | |
| 2873 | giveaway | |
| 2874 | given | |
| 2875 | giver | |
| 2876 | giving | |
| 2877 | gizmo | |
| 2878 | gizzard | |
| 2879 | glacial | |
| 2880 | glacier | |
| 2881 | glade | |
| 2882 | gladiator | |
| 2883 | gladly | |
| 2884 | glamorous | |
| 2885 | glamour | |
| 2886 | glance | |
| 2887 | glancing | |
| 2888 | glandular | |
| 2889 | glare | |
| 2890 | glaring | |
| 2891 | glass | |
| 2892 | glaucoma | |
| 2893 | glazing | |
| 2894 | gleaming | |
| 2895 | gleeful | |
| 2896 | glider | |
| 2897 | gliding | |
| 2898 | glimmer | |
| 2899 | glimpse | |
| 2900 | glisten | |
| 2901 | glitch | |
| 2902 | glitter | |
| 2903 | glitzy | |
| 2904 | gloater | |
| 2905 | gloating | |
| 2906 | gloomily | |
| 2907 | gloomy | |
| 2908 | glorified | |
| 2909 | glorifier | |
| 2910 | glorify | |
| 2911 | glorious | |
| 2912 | glory | |
| 2913 | gloss | |
| 2914 | glove | |
| 2915 | glowing | |
| 2916 | glowworm | |
| 2917 | glucose | |
| 2918 | glue | |
| 2919 | gluten | |
| 2920 | glutinous | |
| 2921 | glutton | |
| 2922 | gnarly | |
| 2923 | gnat | |
| 2924 | goal | |
| 2925 | goatskin | |
| 2926 | goes | |
| 2927 | goggles | |
| 2928 | going | |
| 2929 | goldfish | |
| 2930 | goldmine | |
| 2931 | goldsmith | |
| 2932 | golf | |
| 2933 | goliath | |
| 2934 | gonad | |
| 2935 | gondola | |
| 2936 | gone | |
| 2937 | gong | |
| 2938 | good | |
| 2939 | gooey | |
| 2940 | goofball | |
| 2941 | goofiness | |
| 2942 | goofy | |
| 2943 | ||
| 2944 | goon | |
| 2945 | gopher | |
| 2946 | gore | |
| 2947 | gorged | |
| 2948 | gorgeous | |
| 2949 | gory | |
| 2950 | gosling | |
| 2951 | gossip | |
| 2952 | gothic | |
| 2953 | gotten | |
| 2954 | gout | |
| 2955 | gown | |
| 2956 | grab | |
| 2957 | graceful | |
| 2958 | graceless | |
| 2959 | gracious | |
| 2960 | gradation | |
| 2961 | graded | |
| 2962 | grader | |
| 2963 | gradient | |
| 2964 | grading | |
| 2965 | gradually | |
| 2966 | graduate | |
| 2967 | graffiti | |
| 2968 | grafted | |
| 2969 | grafting | |
| 2970 | grain | |
| 2971 | granddad | |
| 2972 | grandkid | |
| 2973 | grandly | |
| 2974 | grandma | |
| 2975 | grandpa | |
| 2976 | grandson | |
| 2977 | granite | |
| 2978 | granny | |
| 2979 | granola | |
| 2980 | grant | |
| 2981 | granular | |
| 2982 | grape | |
| 2983 | graph | |
| 2984 | grapple | |
| 2985 | grappling | |
| 2986 | grasp | |
| 2987 | grass | |
| 2988 | gratified | |
| 2989 | gratify | |
| 2990 | grating | |
| 2991 | gratitude | |
| 2992 | gratuity | |
| 2993 | gravel | |
| 2994 | graveness | |
| 2995 | graves | |
| 2996 | graveyard | |
| 2997 | gravitate | |
| 2998 | gravity | |
| 2999 | gravy | |
| 3000 | gray | |
| 3001 | grazing | |
| 3002 | greasily | |
| 3003 | greedily | |
| 3004 | greedless | |
| 3005 | greedy | |
| 3006 | green | |
| 3007 | greeter | |
| 3008 | greeting | |
| 3009 | grew | |
| 3010 | greyhound | |
| 3011 | grid | |
| 3012 | grief | |
| 3013 | grievance | |
| 3014 | grieving | |
| 3015 | grievous | |
| 3016 | grill | |
| 3017 | grimace | |
| 3018 | grimacing | |
| 3019 | grime | |
| 3020 | griminess | |
| 3021 | grimy | |
| 3022 | grinch | |
| 3023 | grinning | |
| 3024 | grip | |
| 3025 | gristle | |
| 3026 | grit | |
| 3027 | groggily | |
| 3028 | groggy | |
| 3029 | groin | |
| 3030 | groom | |
| 3031 | groove | |
| 3032 | grooving | |
| 3033 | groovy | |
| 3034 | grope | |
| 3035 | ground | |
| 3036 | grouped | |
| 3037 | grout | |
| 3038 | grove | |
| 3039 | grower | |
| 3040 | growing | |
| 3041 | growl | |
| 3042 | grub | |
| 3043 | grudge | |
| 3044 | grudging | |
| 3045 | grueling | |
| 3046 | gruffly | |
| 3047 | grumble | |
| 3048 | grumbling | |
| 3049 | grumbly | |
| 3050 | grumpily | |
| 3051 | grunge | |
| 3052 | grunt | |
| 3053 | guacamole | |
| 3054 | guidable | |
| 3055 | guidance | |
| 3056 | guide | |
| 3057 | guiding | |
| 3058 | guileless | |
| 3059 | guise | |
| 3060 | gulf | |
| 3061 | gullible | |
| 3062 | gully | |
| 3063 | gulp | |
| 3064 | gumball | |
| 3065 | gumdrop | |
| 3066 | gumminess | |
| 3067 | gumming | |
| 3068 | gummy | |
| 3069 | gurgle | |
| 3070 | gurgling | |
| 3071 | guru | |
| 3072 | gush | |
| 3073 | gusto | |
| 3074 | gusty | |
| 3075 | gutless | |
| 3076 | guts | |
| 3077 | gutter | |
| 3078 | guy | |
| 3079 | guzzler | |
| 3080 | gyration | |
| 3081 | habitable | |
| 3082 | habitant | |
| 3083 | habitat | |
| 3084 | habitual | |
| 3085 | hacked | |
| 3086 | hacker | |
| 3087 | hacking | |
| 3088 | hacksaw | |
| 3089 | had | |
| 3090 | haggler | |
| 3091 | haiku | |
| 3092 | half | |
| 3093 | halogen | |
| 3094 | halt | |
| 3095 | halved | |
| 3096 | halves | |
| 3097 | hamburger | |
| 3098 | hamlet | |
| 3099 | hammock | |
| 3100 | hamper | |
| 3101 | hamster | |
| 3102 | hamstring | |
| 3103 | handbag | |
| 3104 | handball | |
| 3105 | handbook | |
| 3106 | handbrake | |
| 3107 | handcart | |
| 3108 | handclap | |
| 3109 | handclasp | |
| 3110 | handcraft | |
| 3111 | handcuff | |
| 3112 | handed | |
| 3113 | handful | |
| 3114 | handgrip | |
| 3115 | handgun | |
| 3116 | handheld | |
| 3117 | handiness | |
| 3118 | handiwork | |
| 3119 | handlebar | |
| 3120 | handled | |
| 3121 | handler | |
| 3122 | handling | |
| 3123 | handmade | |
| 3124 | handoff | |
| 3125 | handpick | |
| 3126 | handprint | |
| 3127 | handrail | |
| 3128 | handsaw | |
| 3129 | handset | |
| 3130 | handsfree | |
| 3131 | handshake | |
| 3132 | handstand | |
| 3133 | handwash | |
| 3134 | handwork | |
| 3135 | handwoven | |
| 3136 | handwrite | |
| 3137 | handyman | |
| 3138 | hangnail | |
| 3139 | hangout | |
| 3140 | hangover | |
| 3141 | hangup | |
| 3142 | hankering | |
| 3143 | hankie | |
| 3144 | hanky | |
| 3145 | haphazard | |
| 3146 | happening | |
| 3147 | happier | |
| 3148 | happiest | |
| 3149 | happily | |
| 3150 | happiness | |
| 3151 | happy | |
| 3152 | harbor | |
| 3153 | hardcopy | |
| 3154 | hardcore | |
| 3155 | hardcover | |
| 3156 | harddisk | |
| 3157 | hardened | |
| 3158 | hardener | |
| 3159 | hardening | |
| 3160 | hardhat | |
| 3161 | hardhead | |
| 3162 | hardiness | |
| 3163 | hardly | |
| 3164 | hardness | |
| 3165 | hardship | |
| 3166 | hardware | |
| 3167 | hardwired | |
| 3168 | hardwood | |
| 3169 | hardy | |
| 3170 | harmful | |
| 3171 | harmless | |
| 3172 | harmonica | |
| 3173 | harmonics | |
| 3174 | harmonize | |
| 3175 | harmony | |
| 3176 | harness | |
| 3177 | harpist | |
| 3178 | harsh | |
| 3179 | harvest | |
| 3180 | hash | |
| 3181 | hassle | |
| 3182 | haste | |
| 3183 | hastily | |
| 3184 | hastiness | |
| 3185 | hasty | |
| 3186 | hatbox | |
| 3187 | hatchback | |
| 3188 | hatchery | |
| 3189 | hatchet | |
| 3190 | hatching | |
| 3191 | hatchling | |
| 3192 | hate | |
| 3193 | hatless | |
| 3194 | hatred | |
| 3195 | haunt | |
| 3196 | haven | |
| 3197 | hazard | |
| 3198 | hazelnut | |
| 3199 | hazily | |
| 3200 | haziness | |
| 3201 | hazing | |
| 3202 | hazy | |
| 3203 | headache | |
| 3204 | headband | |
| 3205 | headboard | |
| 3206 | headcount | |
| 3207 | headdress | |
| 3208 | headed | |
| 3209 | header | |
| 3210 | headfirst | |
| 3211 | headgear | |
| 3212 | heading | |
| 3213 | headlamp | |
| 3214 | headless | |
| 3215 | headlock | |
| 3216 | headphone | |
| 3217 | headpiece | |
| 3218 | headrest | |
| 3219 | headroom | |
| 3220 | headscarf | |
| 3221 | headset | |
| 3222 | headsman | |
| 3223 | headstand | |
| 3224 | headstone | |
| 3225 | headway | |
| 3226 | headwear | |
| 3227 | heap | |
| 3228 | heat | |
| 3229 | heave | |
| 3230 | heavily | |
| 3231 | heaviness | |
| 3232 | heaving | |
| 3233 | hedge | |
| 3234 | hedging | |
| 3235 | heftiness | |
| 3236 | hefty | |
| 3237 | helium | |
| 3238 | helmet | |
| 3239 | helper | |
| 3240 | helpful | |
| 3241 | helping | |
| 3242 | helpless | |
| 3243 | helpline | |
| 3244 | hemlock | |
| 3245 | hemstitch | |
| 3246 | hence | |
| 3247 | henchman | |
| 3248 | henna | |
| 3249 | herald | |
| 3250 | herbal | |
| 3251 | herbicide | |
| 3252 | herbs | |
| 3253 | heritage | |
| 3254 | hermit | |
| 3255 | heroics | |
| 3256 | heroism | |
| 3257 | herring | |
| 3258 | herself | |
| 3259 | hertz | |
| 3260 | hesitancy | |
| 3261 | hesitant | |
| 3262 | hesitate | |
| 3263 | hexagon | |
| 3264 | hexagram | |
| 3265 | hubcap | |
| 3266 | huddle | |
| 3267 | huddling | |
| 3268 | huff | |
| 3269 | hug | |
| 3270 | hula | |
| 3271 | hulk | |
| 3272 | hull | |
| 3273 | human | |
| 3274 | humble | |
| 3275 | humbling | |
| 3276 | humbly | |
| 3277 | humid | |
| 3278 | humiliate | |
| 3279 | humility | |
| 3280 | humming | |
| 3281 | hummus | |
| 3282 | humongous | |
| 3283 | humorist | |
| 3284 | humorless | |
| 3285 | humorous | |
| 3286 | humpback | |
| 3287 | humped | |
| 3288 | humvee | |
| 3289 | hunchback | |
| 3290 | hundredth | |
| 3291 | hunger | |
| 3292 | hungrily | |
| 3293 | hungry | |
| 3294 | hunk | |
| 3295 | hunter | |
| 3296 | hunting | |
| 3297 | huntress | |
| 3298 | huntsman | |
| 3299 | hurdle | |
| 3300 | hurled | |
| 3301 | hurler | |
| 3302 | hurling | |
| 3303 | hurray | |
| 3304 | hurricane | |
| 3305 | hurried | |
| 3306 | hurry | |
| 3307 | hurt | |
| 3308 | husband | |
| 3309 | hush | |
| 3310 | husked | |
| 3311 | huskiness | |
| 3312 | hut | |
| 3313 | hybrid | |
| 3314 | hydrant | |
| 3315 | hydrated | |
| 3316 | hydration | |
| 3317 | hydrogen | |
| 3318 | hydroxide | |
| 3319 | hyperlink | |
| 3320 | hypertext | |
| 3321 | hyphen | |
| 3322 | hypnoses | |
| 3323 | hypnosis | |
| 3324 | hypnotic | |
| 3325 | hypnotism | |
| 3326 | hypnotist | |
| 3327 | hypnotize | |
| 3328 | hypocrisy | |
| 3329 | hypocrite | |
| 3330 | ibuprofen | |
| 3331 | ice | |
| 3332 | iciness | |
| 3333 | icing | |
| 3334 | icky | |
| 3335 | icon | |
| 3336 | icy | |
| 3337 | idealism | |
| 3338 | idealist | |
| 3339 | idealize | |
| 3340 | ideally | |
| 3341 | idealness | |
| 3342 | identical | |
| 3343 | identify | |
| 3344 | identity | |
| 3345 | ideology | |
| 3346 | idiocy | |
| 3347 | idiom | |
| 3348 | idly | |
| 3349 | igloo | |
| 3350 | ignition | |
| 3351 | ignore | |
| 3352 | iguana | |
| 3353 | illicitly | |
| 3354 | illusion | |
| 3355 | illusive | |
| 3356 | image | |
| 3357 | imaginary | |
| 3358 | imagines | |
| 3359 | imaging | |
| 3360 | imbecile | |
| 3361 | imitate | |
| 3362 | imitation | |
| 3363 | immature | |
| 3364 | immerse | |
| 3365 | immersion | |
| 3366 | imminent | |
| 3367 | immobile | |
| 3368 | immodest | |
| 3369 | immorally | |
| 3370 | immortal | |
| 3371 | immovable | |
| 3372 | immovably | |
| 3373 | immunity | |
| 3374 | immunize | |
| 3375 | impaired | |
| 3376 | impale | |
| 3377 | impart | |
| 3378 | impatient | |
| 3379 | impeach | |
| 3380 | impeding | |
| 3381 | impending | |
| 3382 | imperfect | |
| 3383 | imperial | |
| 3384 | impish | |
| 3385 | implant | |
| 3386 | implement | |
| 3387 | implicate | |
| 3388 | implicit | |
| 3389 | implode | |
| 3390 | implosion | |
| 3391 | implosive | |
| 3392 | imply | |
| 3393 | impolite | |
| 3394 | important | |
| 3395 | importer | |
| 3396 | impose | |
| 3397 | imposing | |
| 3398 | impotence | |
| 3399 | impotency | |
| 3400 | impotent | |
| 3401 | impound | |
| 3402 | imprecise | |
| 3403 | imprint | |
| 3404 | imprison | |
| 3405 | impromptu | |
| 3406 | improper | |
| 3407 | improve | |
| 3408 | improving | |
| 3409 | improvise | |
| 3410 | imprudent | |
| 3411 | impulse | |
| 3412 | impulsive | |
| 3413 | impure | |
| 3414 | impurity | |
| 3415 | iodine | |
| 3416 | iodize | |
| 3417 | ion | |
| 3418 | ipad | |
| 3419 | iphone | |
| 3420 | ipod | |
| 3421 | irate | |
| 3422 | irk | |
| 3423 | iron | |
| 3424 | irregular | |
| 3425 | irrigate | |
| 3426 | irritable | |
| 3427 | irritably | |
| 3428 | irritant | |
| 3429 | irritate | |
| 3430 | islamic | |
| 3431 | islamist | |
| 3432 | isolated | |
| 3433 | isolating | |
| 3434 | isolation | |
| 3435 | isotope | |
| 3436 | issue | |
| 3437 | issuing | |
| 3438 | italicize | |
| 3439 | italics | |
| 3440 | item | |
| 3441 | itinerary | |
| 3442 | itunes | |
| 3443 | ivory | |
| 3444 | ivy | |
| 3445 | jab | |
| 3446 | jackal | |
| 3447 | jacket | |
| 3448 | jackknife | |
| 3449 | jackpot | |
| 3450 | jailbird | |
| 3451 | jailbreak | |
| 3452 | jailer | |
| 3453 | jailhouse | |
| 3454 | jalapeno | |
| 3455 | jam | |
| 3456 | janitor | |
| 3457 | january | |
| 3458 | jargon | |
| 3459 | jarring | |
| 3460 | jasmine | |
| 3461 | jaundice | |
| 3462 | jaunt | |
| 3463 | java | |
| 3464 | jawed | |
| 3465 | jawless | |
| 3466 | jawline | |
| 3467 | jaws | |
| 3468 | jaybird | |
| 3469 | jaywalker | |
| 3470 | jazz | |
| 3471 | jeep | |
| 3472 | jeeringly | |
| 3473 | jellied | |
| 3474 | jelly | |
| 3475 | jersey | |
| 3476 | jester | |
| 3477 | jet | |
| 3478 | jiffy | |
| 3479 | jigsaw | |
| 3480 | jimmy | |
| 3481 | jingle | |
| 3482 | jingling | |
| 3483 | jinx | |
| 3484 | jitters | |
| 3485 | jittery | |
| 3486 | job | |
| 3487 | jockey | |
| 3488 | jockstrap | |
| 3489 | jogger | |
| 3490 | jogging | |
| 3491 | john | |
| 3492 | joining | |
| 3493 | jokester | |
| 3494 | jokingly | |
| 3495 | jolliness | |
| 3496 | jolly | |
| 3497 | jolt | |
| 3498 | jot | |
| 3499 | jovial | |
| 3500 | joyfully | |
| 3501 | joylessly | |
| 3502 | joyous | |
| 3503 | joyride | |
| 3504 | joystick | |
| 3505 | jubilance | |
| 3506 | jubilant | |
| 3507 | judge | |
| 3508 | judgingly | |
| 3509 | judicial | |
| 3510 | judiciary | |
| 3511 | judo | |
| 3512 | juggle | |
| 3513 | juggling | |
| 3514 | jugular | |
| 3515 | juice | |
| 3516 | juiciness | |
| 3517 | juicy | |
| 3518 | jujitsu | |
| 3519 | jukebox | |
| 3520 | july | |
| 3521 | jumble | |
| 3522 | jumbo | |
| 3523 | jump | |
| 3524 | junction | |
| 3525 | juncture | |
| 3526 | june | |
| 3527 | junior | |
| 3528 | juniper | |
| 3529 | junkie | |
| 3530 | junkman | |
| 3531 | junkyard | |
| 3532 | jurist | |
| 3533 | juror | |
| 3534 | jury | |
| 3535 | justice | |
| 3536 | justifier | |
| 3537 | justify | |
| 3538 | justly | |
| 3539 | justness | |
| 3540 | juvenile | |
| 3541 | kabob | |
| 3542 | kangaroo | |
| 3543 | karaoke | |
| 3544 | karate | |
| 3545 | karma | |
| 3546 | kebab | |
| 3547 | keenly | |
| 3548 | keenness | |
| 3549 | keep | |
| 3550 | keg | |
| 3551 | kelp | |
| 3552 | kennel | |
| 3553 | kept | |
| 3554 | kerchief | |
| 3555 | kerosene | |
| 3556 | kettle | |
| 3557 | kick | |
| 3558 | kiln | |
| 3559 | kilobyte | |
| 3560 | kilogram | |
| 3561 | kilometer | |
| 3562 | kilowatt | |
| 3563 | kilt | |
| 3564 | kimono | |
| 3565 | kindle | |
| 3566 | kindling | |
| 3567 | kindly | |
| 3568 | kindness | |
| 3569 | kindred | |
| 3570 | kinetic | |
| 3571 | kinfolk | |
| 3572 | king | |
| 3573 | kinship | |
| 3574 | kinsman | |
| 3575 | kinswoman | |
| 3576 | kissable | |
| 3577 | kisser | |
| 3578 | kissing | |
| 3579 | kitchen | |
| 3580 | kite | |
| 3581 | kitten | |
| 3582 | kitty | |
| 3583 | kiwi | |
| 3584 | kleenex | |
| 3585 | knapsack | |
| 3586 | knee | |
| 3587 | knelt | |
| 3588 | knickers | |
| 3589 | knoll | |
| 3590 | koala | |
| 3591 | kooky | |
| 3592 | kosher | |
| 3593 | krypton | |
| 3594 | kudos | |
| 3595 | kung | |
| 3596 | labored | |
| 3597 | laborer | |
| 3598 | laboring | |
| 3599 | laborious | |
| 3600 | labrador | |
| 3601 | ladder | |
| 3602 | ladies | |
| 3603 | ladle | |
| 3604 | ladybug | |
| 3605 | ladylike | |
| 3606 | lagged | |
| 3607 | lagging | |
| 3608 | lagoon | |
| 3609 | lair | |
| 3610 | lake | |
| 3611 | lance | |
| 3612 | landed | |
| 3613 | landfall | |
| 3614 | landfill | |
| 3615 | landing | |
| 3616 | landlady | |
| 3617 | landless | |
| 3618 | landline | |
| 3619 | landlord | |
| 3620 | landmark | |
| 3621 | landmass | |
| 3622 | landmine | |
| 3623 | landowner | |
| 3624 | landscape | |
| 3625 | landside | |
| 3626 | landslide | |
| 3627 | language | |
| 3628 | lankiness | |
| 3629 | lanky | |
| 3630 | lantern | |
| 3631 | lapdog | |
| 3632 | lapel | |
| 3633 | lapped | |
| 3634 | lapping | |
| 3635 | laptop | |
| 3636 | lard | |
| 3637 | large | |
| 3638 | lark | |
| 3639 | lash | |
| 3640 | lasso | |
| 3641 | last | |
| 3642 | latch | |
| 3643 | late | |
| 3644 | lather | |
| 3645 | latitude | |
| 3646 | latrine | |
| 3647 | latter | |
| 3648 | latticed | |
| 3649 | launch | |
| 3650 | launder | |
| 3651 | laundry | |
| 3652 | laurel | |
| 3653 | lavender | |
| 3654 | lavish | |
| 3655 | laxative | |
| 3656 | lazily | |
| 3657 | laziness | |
| 3658 | lazy | |
| 3659 | lecturer | |
| 3660 | left | |
| 3661 | legacy | |
| 3662 | legal | |
| 3663 | legend | |
| 3664 | legged | |
| 3665 | leggings | |
| 3666 | legible | |
| 3667 | legibly | |
| 3668 | legislate | |
| 3669 | lego | |
| 3670 | legroom | |
| 3671 | legume | |
| 3672 | legwarmer | |
| 3673 | legwork | |
| 3674 | lemon | |
| 3675 | lend | |
| 3676 | length | |
| 3677 | lens | |
| 3678 | lent | |
| 3679 | leotard | |
| 3680 | lesser | |
| 3681 | letdown | |
| 3682 | lethargic | |
| 3683 | lethargy | |
| 3684 | letter | |
| 3685 | lettuce | |
| 3686 | level | |
| 3687 | leverage | |
| 3688 | levers | |
| 3689 | levitate | |
| 3690 | levitator | |
| 3691 | liability | |
| 3692 | liable | |
| 3693 | liberty | |
| 3694 | librarian | |
| 3695 | library | |
| 3696 | licking | |
| 3697 | licorice | |
| 3698 | lid | |
| 3699 | life | |
| 3700 | lifter | |
| 3701 | lifting | |
| 3702 | liftoff | |
| 3703 | ligament | |
| 3704 | likely | |
| 3705 | likeness | |
| 3706 | likewise | |
| 3707 | liking | |
| 3708 | lilac | |
| 3709 | lilly | |
| 3710 | lily | |
| 3711 | limb | |
| 3712 | limeade | |
| 3713 | limelight | |
| 3714 | limes | |
| 3715 | limit | |
| 3716 | limping | |
| 3717 | limpness | |
| 3718 | line | |
| 3719 | lingo | |
| 3720 | linguini | |
| 3721 | linguist | |
| 3722 | lining | |
| 3723 | linked | |
| 3724 | linoleum | |
| 3725 | linseed | |
| 3726 | lint | |
| 3727 | lion | |
| 3728 | lip | |
| 3729 | liquefy | |
| 3730 | liqueur | |
| 3731 | liquid | |
| 3732 | lisp | |
| 3733 | list | |
| 3734 | litigate | |
| 3735 | litigator | |
| 3736 | litmus | |
| 3737 | litter | |
| 3738 | little | |
| 3739 | livable | |
| 3740 | lived | |
| 3741 | lively | |
| 3742 | liver | |
| 3743 | livestock | |
| 3744 | lividly | |
| 3745 | living | |
| 3746 | lizard | |
| 3747 | lubricant | |
| 3748 | lubricate | |
| 3749 | lucid | |
| 3750 | luckily | |
| 3751 | luckiness | |
| 3752 | luckless | |
| 3753 | lucrative | |
| 3754 | ludicrous | |
| 3755 | lugged | |
| 3756 | lukewarm | |
| 3757 | lullaby | |
| 3758 | lumber | |
| 3759 | luminance | |
| 3760 | luminous | |
| 3761 | lumpiness | |
| 3762 | lumping | |
| 3763 | lumpish | |
| 3764 | lunacy | |
| 3765 | lunar | |
| 3766 | lunchbox | |
| 3767 | luncheon | |
| 3768 | lunchroom | |
| 3769 | lunchtime | |
| 3770 | lung | |
| 3771 | lurch | |
| 3772 | lure | |
| 3773 | luridness | |
| 3774 | lurk | |
| 3775 | lushly | |
| 3776 | lushness | |
| 3777 | luster | |
| 3778 | lustfully | |
| 3779 | lustily | |
| 3780 | lustiness | |
| 3781 | lustrous | |
| 3782 | lusty | |
| 3783 | luxurious | |
| 3784 | luxury | |
| 3785 | lying | |
| 3786 | lyrically | |
| 3787 | lyricism | |
| 3788 | lyricist | |
| 3789 | lyrics | |
| 3790 | macarena | |
| 3791 | macaroni | |
| 3792 | macaw | |
| 3793 | mace | |
| 3794 | machine | |
| 3795 | machinist | |
| 3796 | magazine | |
| 3797 | magenta | |
| 3798 | maggot | |
| 3799 | magical | |
| 3800 | magician | |
| 3801 | magma | |
| 3802 | magnesium | |
| 3803 | magnetic | |
| 3804 | magnetism | |
| 3805 | magnetize | |
| 3806 | magnifier | |
| 3807 | magnify | |
| 3808 | magnitude | |
| 3809 | magnolia | |
| 3810 | mahogany | |
| 3811 | maimed | |
| 3812 | majestic | |
| 3813 | majesty | |
| 3814 | majorette | |
| 3815 | majority | |
| 3816 | makeover | |
| 3817 | maker | |
| 3818 | makeshift | |
| 3819 | making | |
| 3820 | malformed | |
| 3821 | malt | |
| 3822 | mama | |
| 3823 | mammal | |
| 3824 | mammary | |
| 3825 | mammogram | |
| 3826 | manager | |
| 3827 | managing | |
| 3828 | manatee | |
| 3829 | mandarin | |
| 3830 | mandate | |
| 3831 | mandatory | |
| 3832 | mandolin | |
| 3833 | manger | |
| 3834 | mangle | |
| 3835 | mango | |
| 3836 | mangy | |
| 3837 | manhandle | |
| 3838 | manhole | |
| 3839 | manhood | |
| 3840 | manhunt | |
| 3841 | manicotti | |
| 3842 | manicure | |
| 3843 | manifesto | |
| 3844 | manila | |
| 3845 | mankind | |
| 3846 | manlike | |
| 3847 | manliness | |
| 3848 | manly | |
| 3849 | manmade | |
| 3850 | manned | |
| 3851 | mannish | |
| 3852 | manor | |
| 3853 | manpower | |
| 3854 | mantis | |
| 3855 | mantra | |
| 3856 | manual | |
| 3857 | many | |
| 3858 | map | |
| 3859 | marathon | |
| 3860 | marauding | |
| 3861 | marbled | |
| 3862 | marbles | |
| 3863 | marbling | |
| 3864 | march | |
| 3865 | mardi | |
| 3866 | margarine | |
| 3867 | margarita | |
| 3868 | margin | |
| 3869 | marigold | |
| 3870 | marina | |
| 3871 | marine | |
| 3872 | marital | |
| 3873 | maritime | |
| 3874 | marlin | |
| 3875 | marmalade | |
| 3876 | maroon | |
| 3877 | married | |
| 3878 | marrow | |
| 3879 | marry | |
| 3880 | marshland | |
| 3881 | marshy | |
| 3882 | marsupial | |
| 3883 | marvelous | |
| 3884 | marxism | |
| 3885 | mascot | |
| 3886 | masculine | |
| 3887 | mashed | |
| 3888 | mashing | |
| 3889 | massager | |
| 3890 | masses | |
| 3891 | massive | |
| 3892 | mastiff | |
| 3893 | matador | |
| 3894 | matchbook | |
| 3895 | matchbox | |
| 3896 | matcher | |
| 3897 | matching | |
| 3898 | matchless | |
| 3899 | material | |
| 3900 | maternal | |
| 3901 | maternity | |
| 3902 | math | |
| 3903 | mating | |
| 3904 | matriarch | |
| 3905 | matrimony | |
| 3906 | matrix | |
| 3907 | matron | |
| 3908 | matted | |
| 3909 | matter | |
| 3910 | maturely | |
| 3911 | maturing | |
| 3912 | maturity | |
| 3913 | mauve | |
| 3914 | maverick | |
| 3915 | maximize | |
| 3916 | maximum | |
| 3917 | maybe | |
| 3918 | mayday | |
| 3919 | mayflower | |
| 3920 | moaner | |
| 3921 | moaning | |
| 3922 | mobile | |
| 3923 | mobility | |
| 3924 | mobilize | |
| 3925 | mobster | |
| 3926 | mocha | |
| 3927 | mocker | |
| 3928 | mockup | |
| 3929 | modified | |
| 3930 | modify | |
| 3931 | modular | |
| 3932 | modulator | |
| 3933 | module | |
| 3934 | moisten | |
| 3935 | moistness | |
| 3936 | moisture | |
| 3937 | molar | |
| 3938 | molasses | |
| 3939 | mold | |
| 3940 | molecular | |
| 3941 | molecule | |
| 3942 | molehill | |
| 3943 | mollusk | |
| 3944 | mom | |
| 3945 | monastery | |
| 3946 | monday | |
| 3947 | monetary | |
| 3948 | monetize | |
| 3949 | moneybags | |
| 3950 | moneyless | |
| 3951 | moneywise | |
| 3952 | mongoose | |
| 3953 | mongrel | |
| 3954 | monitor | |
| 3955 | monkhood | |
| 3956 | monogamy | |
| 3957 | monogram | |
| 3958 | monologue | |
| 3959 | monopoly | |
| 3960 | monorail | |
| 3961 | monotone | |
| 3962 | monotype | |
| 3963 | monoxide | |
| 3964 | monsieur | |
| 3965 | monsoon | |
| 3966 | monstrous | |
| 3967 | monthly | |
| 3968 | monument | |
| 3969 | moocher | |
| 3970 | moodiness | |
| 3971 | moody | |
| 3972 | mooing | |
| 3973 | moonbeam | |
| 3974 | mooned | |
| 3975 | moonlight | |
| 3976 | moonlike | |
| 3977 | moonlit | |
| 3978 | moonrise | |
| 3979 | moonscape | |
| 3980 | moonshine | |
| 3981 | moonstone | |
| 3982 | moonwalk | |
| 3983 | mop | |
| 3984 | morale | |
| 3985 | morality | |
| 3986 | morally | |
| 3987 | morbidity | |
| 3988 | morbidly | |
| 3989 | morphine | |
| 3990 | morphing | |
| 3991 | morse | |
| 3992 | mortality | |
| 3993 | mortally | |
| 3994 | mortician | |
| 3995 | mortified | |
| 3996 | mortify | |
| 3997 | mortuary | |
| 3998 | mosaic | |
| 3999 | mossy | |
| 4000 | most | |
| 4001 | mothball | |
| 4002 | mothproof | |
| 4003 | motion | |
| 4004 | motivate | |
| 4005 | motivator | |
| 4006 | motive | |
| 4007 | motocross | |
| 4008 | motor | |
| 4009 | motto | |
| 4010 | mountable | |
| 4011 | mountain | |
| 4012 | mounted | |
| 4013 | mounting | |
| 4014 | mourner | |
| 4015 | mournful | |
| 4016 | mouse | |
| 4017 | mousiness | |
| 4018 | moustache | |
| 4019 | mousy | |
| 4020 | mouth | |
| 4021 | movable | |
| 4022 | move | |
| 4023 | movie | |
| 4024 | moving | |
| 4025 | mower | |
| 4026 | mowing | |
| 4027 | much | |
| 4028 | muck | |
| 4029 | mud | |
| 4030 | mug | |
| 4031 | mulberry | |
| 4032 | mulch | |
| 4033 | mule | |
| 4034 | mulled | |
| 4035 | mullets | |
| 4036 | multiple | |
| 4037 | multiply | |
| 4038 | multitask | |
| 4039 | multitude | |
| 4040 | mumble | |
| 4041 | mumbling | |
| 4042 | mumbo | |
| 4043 | mummified | |
| 4044 | mummify | |
| 4045 | mummy | |
| 4046 | mumps | |
| 4047 | munchkin | |
| 4048 | mundane | |
| 4049 | municipal | |
| 4050 | muppet | |
| 4051 | mural | |
| 4052 | murkiness | |
| 4053 | murky | |
| 4054 | murmuring | |
| 4055 | muscular | |
| 4056 | museum | |
| 4057 | mushily | |
| 4058 | mushiness | |
| 4059 | mushroom | |
| 4060 | mushy | |
| 4061 | music | |
| 4062 | musket | |
| 4063 | muskiness | |
| 4064 | musky | |
| 4065 | mustang | |
| 4066 | mustard | |
| 4067 | muster | |
| 4068 | mustiness | |
| 4069 | musty | |
| 4070 | mutable | |
| 4071 | mutate | |
| 4072 | mutation | |
| 4073 | mute | |
| 4074 | mutilated | |
| 4075 | mutilator | |
| 4076 | mutiny | |
| 4077 | mutt | |
| 4078 | mutual | |
| 4079 | muzzle | |
| 4080 | myself | |
| 4081 | myspace | |
| 4082 | mystified | |
| 4083 | mystify | |
| 4084 | myth | |
| 4085 | nacho | |
| 4086 | nag | |
| 4087 | nail | |
| 4088 | name | |
| 4089 | naming | |
| 4090 | nanny | |
| 4091 | nanometer | |
| 4092 | nape | |
| 4093 | napkin | |
| 4094 | napped | |
| 4095 | napping | |
| 4096 | nappy | |
| 4097 | narrow | |
| 4098 | nastily | |
| 4099 | nastiness | |
| 4100 | national | |
| 4101 | native | |
| 4102 | nativity | |
| 4103 | natural | |
| 4104 | nature | |
| 4105 | naturist | |
| 4106 | nautical | |
| 4107 | navigate | |
| 4108 | navigator | |
| 4109 | navy | |
| 4110 | nearby | |
| 4111 | nearest | |
| 4112 | nearly | |
| 4113 | nearness | |
| 4114 | neatly | |
| 4115 | neatness | |
| 4116 | nebula | |
| 4117 | nebulizer | |
| 4118 | nectar | |
| 4119 | negate | |
| 4120 | negation | |
| 4121 | negative | |
| 4122 | neglector | |
| 4123 | negligee | |
| 4124 | negligent | |
| 4125 | negotiate | |
| 4126 | nemeses | |
| 4127 | nemesis | |
| 4128 | neon | |
| 4129 | nephew | |
| 4130 | nerd | |
| 4131 | nervous | |
| 4132 | nervy | |
| 4133 | nest | |
| 4134 | net | |
| 4135 | neurology | |
| 4136 | neuron | |
| 4137 | neurosis | |
| 4138 | neurotic | |
| 4139 | neuter | |
| 4140 | neutron | |
| 4141 | never | |
| 4142 | next | |
| 4143 | nibble | |
| 4144 | nickname | |
| 4145 | nicotine | |
| 4146 | niece | |
| 4147 | nifty | |
| 4148 | nimble | |
| 4149 | nimbly | |
| 4150 | nineteen | |
| 4151 | ninetieth | |
| 4152 | ninja | |
| 4153 | nintendo | |
| 4154 | ninth | |
| 4155 | nuclear | |
| 4156 | nuclei | |
| 4157 | nucleus | |
| 4158 | nugget | |
| 4159 | nullify | |
| 4160 | number | |
| 4161 | numbing | |
| 4162 | numbly | |
| 4163 | numbness | |
| 4164 | numeral | |
| 4165 | numerate | |
| 4166 | numerator | |
| 4167 | numeric | |
| 4168 | numerous | |
| 4169 | nuptials | |
| 4170 | nursery | |
| 4171 | nursing | |
| 4172 | nurture | |
| 4173 | nutcase | |
| 4174 | nutlike | |
| 4175 | nutmeg | |
| 4176 | nutrient | |
| 4177 | nutshell | |
| 4178 | nuttiness | |
| 4179 | nutty | |
| 4180 | nuzzle | |
| 4181 | nylon | |
| 4182 | oaf | |
| 4183 | oak | |
| 4184 | oasis | |
| 4185 | oat | |
| 4186 | obedience | |
| 4187 | obedient | |
| 4188 | obituary | |
| 4189 | object | |
| 4190 | obligate | |
| 4191 | obliged | |
| 4192 | oblivion | |
| 4193 | oblivious | |
| 4194 | oblong | |
| 4195 | obnoxious | |
| 4196 | oboe | |
| 4197 | obscure | |
| 4198 | obscurity | |
| 4199 | observant | |
| 4200 | observer | |
| 4201 | observing | |
| 4202 | obsessed | |
| 4203 | obsession | |
| 4204 | obsessive | |
| 4205 | obsolete | |
| 4206 | obstacle | |
| 4207 | obstinate | |
| 4208 | obstruct | |
| 4209 | obtain | |
| 4210 | obtrusive | |
| 4211 | obtuse | |
| 4212 | obvious | |
| 4213 | occultist | |
| 4214 | occupancy | |
| 4215 | occupant | |
| 4216 | occupier | |
| 4217 | occupy | |
| 4218 | ocean | |
| 4219 | ocelot | |
| 4220 | octagon | |
| 4221 | octane | |
| 4222 | october | |
| 4223 | octopus | |
| 4224 | ogle | |
| 4225 | oil | |
| 4226 | oink | |
| 4227 | ointment | |
| 4228 | okay | |
| 4229 | old | |
| 4230 | olive | |
| 4231 | olympics | |
| 4232 | omega | |
| 4233 | omen | |
| 4234 | ominous | |
| 4235 | omission | |
| 4236 | omit | |
| 4237 | omnivore | |
| 4238 | onboard | |
| 4239 | oncoming | |
| 4240 | ongoing | |
| 4241 | onion | |
| 4242 | online | |
| 4243 | onlooker | |
| 4244 | only | |
| 4245 | onscreen | |
| 4246 | onset | |
| 4247 | onshore | |
| 4248 | onslaught | |
| 4249 | onstage | |
| 4250 | onto | |
| 4251 | onward | |
| 4252 | onyx | |
| 4253 | oops | |
| 4254 | ooze | |
| 4255 | oozy | |
| 4256 | opacity | |
| 4257 | opal | |
| 4258 | open | |
| 4259 | operable | |
| 4260 | operate | |
| 4261 | operating | |
| 4262 | operation | |
| 4263 | operative | |
| 4264 | operator | |
| 4265 | opium | |
| 4266 | opossum | |
| 4267 | opponent | |
| 4268 | oppose | |
| 4269 | opposing | |
| 4270 | opposite | |
| 4271 | oppressed | |
| 4272 | oppressor | |
| 4273 | opt | |
| 4274 | opulently | |
| 4275 | osmosis | |
| 4276 | other | |
| 4277 | otter | |
| 4278 | ouch | |
| 4279 | ought | |
| 4280 | ounce | |
| 4281 | outage | |
| 4282 | outback | |
| 4283 | outbid | |
| 4284 | outboard | |
| 4285 | outbound | |
| 4286 | outbreak | |
| 4287 | outburst | |
| 4288 | outcast | |
| 4289 | outclass | |
| 4290 | outcome | |
| 4291 | outdated | |
| 4292 | outdoors | |
| 4293 | outer | |
| 4294 | outfield | |
| 4295 | outfit | |
| 4296 | outflank | |
| 4297 | outgoing | |
| 4298 | outgrow | |
| 4299 | outhouse | |
| 4300 | outing | |
| 4301 | outlast | |
| 4302 | outlet | |
| 4303 | outline | |
| 4304 | outlook | |
| 4305 | outlying | |
| 4306 | outmatch | |
| 4307 | outmost | |
| 4308 | outnumber | |
| 4309 | outplayed | |
| 4310 | outpost | |
| 4311 | outpour | |
| 4312 | output | |
| 4313 | outrage | |
| 4314 | outrank | |
| 4315 | outreach | |
| 4316 | outright | |
| 4317 | outscore | |
| 4318 | outsell | |
| 4319 | outshine | |
| 4320 | outshoot | |
| 4321 | outsider | |
| 4322 | outskirts | |
| 4323 | outsmart | |
| 4324 | outsource | |
| 4325 | outspoken | |
| 4326 | outtakes | |
| 4327 | outthink | |
| 4328 | outward | |
| 4329 | outweigh | |
| 4330 | outwit | |
| 4331 | oval | |
| 4332 | ovary | |
| 4333 | oven | |
| 4334 | overact | |
| 4335 | overall | |
| 4336 | overarch | |
| 4337 | overbid | |
| 4338 | overbill | |
| 4339 | overbite | |
| 4340 | overblown | |
| 4341 | overboard | |
| 4342 | overbook | |
| 4343 | overbuilt | |
| 4344 | overcast | |
| 4345 | overcoat | |
| 4346 | overcome | |
| 4347 | overcook | |
| 4348 | overcrowd | |
| 4349 | overdraft | |
| 4350 | overdrawn | |
| 4351 | overdress | |
| 4352 | overdrive | |
| 4353 | overdue | |
| 4354 | overeager | |
| 4355 | overeater | |
| 4356 | overexert | |
| 4357 | overfed | |
| 4358 | overfeed | |
| 4359 | overfill | |
| 4360 | overflow | |
| 4361 | overfull | |
| 4362 | overgrown | |
| 4363 | overhand | |
| 4364 | overhang | |
| 4365 | overhaul | |
| 4366 | overhead | |
| 4367 | overhear | |
| 4368 | overheat | |
| 4369 | overhung | |
| 4370 | overjoyed | |
| 4371 | overkill | |
| 4372 | overlabor | |
| 4373 | overlaid | |
| 4374 | overlap | |
| 4375 | overlay | |
| 4376 | overload | |
| 4377 | overlook | |
| 4378 | overlord | |
| 4379 | overlying | |
| 4380 | overnight | |
| 4381 | overpass | |
| 4382 | overpay | |
| 4383 | overplant | |
| 4384 | overplay | |
| 4385 | overpower | |
| 4386 | overprice | |
| 4387 | overrate | |
| 4388 | overreach | |
| 4389 | overreact | |
| 4390 | override | |
| 4391 | overripe | |
| 4392 | overrule | |
| 4393 | overrun | |
| 4394 | overshoot | |
| 4395 | overshot | |
| 4396 | oversight | |
| 4397 | oversized | |
| 4398 | oversleep | |
| 4399 | oversold | |
| 4400 | overspend | |
| 4401 | overstate | |
| 4402 | overstay | |
| 4403 | overstep | |
| 4404 | overstock | |
| 4405 | overstuff | |
| 4406 | oversweet | |
| 4407 | overtake | |
| 4408 | overthrow | |
| 4409 | overtime | |
| 4410 | overtly | |
| 4411 | overtone | |
| 4412 | overture | |
| 4413 | overturn | |
| 4414 | overuse | |
| 4415 | overvalue | |
| 4416 | overview | |
| 4417 | overwrite | |
| 4418 | owl | |
| 4419 | oxford | |
| 4420 | oxidant | |
| 4421 | oxidation | |
| 4422 | oxidize | |
| 4423 | oxidizing | |
| 4424 | oxygen | |
| 4425 | oxymoron | |
| 4426 | oyster | |
| 4427 | ozone | |
| 4428 | paced | |
| 4429 | pacemaker | |
| 4430 | pacific | |
| 4431 | pacifier | |
| 4432 | pacifism | |
| 4433 | pacifist | |
| 4434 | pacify | |
| 4435 | padded | |
| 4436 | padding | |
| 4437 | paddle | |
| 4438 | paddling | |
| 4439 | padlock | |
| 4440 | pagan | |
| 4441 | pager | |
| 4442 | paging | |
| 4443 | pajamas | |
| 4444 | palace | |
| 4445 | palatable | |
| 4446 | palm | |
| 4447 | palpable | |
| 4448 | palpitate | |
| 4449 | paltry | |
| 4450 | pampered | |
| 4451 | pamperer | |
| 4452 | pampers | |
| 4453 | pamphlet | |
| 4454 | panama | |
| 4455 | pancake | |
| 4456 | pancreas | |
| 4457 | panda | |
| 4458 | pandemic | |
| 4459 | pang | |
| 4460 | panhandle | |
| 4461 | panic | |
| 4462 | panning | |
| 4463 | panorama | |
| 4464 | panoramic | |
| 4465 | panther | |
| 4466 | pantomime | |
| 4467 | pantry | |
| 4468 | pants | |
| 4469 | pantyhose | |
| 4470 | paparazzi | |
| 4471 | papaya | |
| 4472 | paper | |
| 4473 | paprika | |
| 4474 | papyrus | |
| 4475 | parabola | |
| 4476 | parachute | |
| 4477 | parade | |
| 4478 | paradox | |
| 4479 | paragraph | |
| 4480 | parakeet | |
| 4481 | paralegal | |
| 4482 | paralyses | |
| 4483 | paralysis | |
| 4484 | paralyze | |
| 4485 | paramedic | |
| 4486 | parameter | |
| 4487 | paramount | |
| 4488 | parasail | |
| 4489 | parasite | |
| 4490 | parasitic | |
| 4491 | parcel | |
| 4492 | parched | |
| 4493 | parchment | |
| 4494 | pardon | |
| 4495 | parish | |
| 4496 | parka | |
| 4497 | parking | |
| 4498 | parkway | |
| 4499 | parlor | |
| 4500 | parmesan | |
| 4501 | parole | |
| 4502 | parrot | |
| 4503 | parsley | |
| 4504 | parsnip | |
| 4505 | partake | |
| 4506 | parted | |
| 4507 | parting | |
| 4508 | partition | |
| 4509 | partly | |
| 4510 | partner | |
| 4511 | partridge | |
| 4512 | party | |
| 4513 | passable | |
| 4514 | passably | |
| 4515 | passage | |
| 4516 | passcode | |
| 4517 | passenger | |
| 4518 | passerby | |
| 4519 | passing | |
| 4520 | passion | |
| 4521 | passive | |
| 4522 | passivism | |
| 4523 | passover | |
| 4524 | passport | |
| 4525 | password | |
| 4526 | pasta | |
| 4527 | pasted | |
| 4528 | pastel | |
| 4529 | pastime | |
| 4530 | pastor | |
| 4531 | pastrami | |
| 4532 | pasture | |
| 4533 | pasty | |
| 4534 | patchwork | |
| 4535 | patchy | |
| 4536 | paternal | |
| 4537 | paternity | |
| 4538 | path | |
| 4539 | patience | |
| 4540 | patient | |
| 4541 | patio | |
| 4542 | patriarch | |
| 4543 | patriot | |
| 4544 | patrol | |
| 4545 | patronage | |
| 4546 | patronize | |
| 4547 | pauper | |
| 4548 | pavement | |
| 4549 | paver | |
| 4550 | pavestone | |
| 4551 | pavilion | |
| 4552 | paving | |
| 4553 | pawing | |
| 4554 | payable | |
| 4555 | payback | |
| 4556 | paycheck | |
| 4557 | payday | |
| 4558 | payee | |
| 4559 | payer | |
| 4560 | paying | |
| 4561 | payment | |
| 4562 | payphone | |
| 4563 | payroll | |
| 4564 | pebble | |
| 4565 | pebbly | |
| 4566 | pecan | |
| 4567 | pectin | |
| 4568 | peculiar | |
| 4569 | peddling | |
| 4570 | pediatric | |
| 4571 | pedicure | |
| 4572 | pedigree | |
| 4573 | pedometer | |
| 4574 | pegboard | |
| 4575 | pelican | |
| 4576 | pellet | |
| 4577 | pelt | |
| 4578 | pelvis | |
| 4579 | penalize | |
| 4580 | penalty | |
| 4581 | pencil | |
| 4582 | pendant | |
| 4583 | pending | |
| 4584 | penholder | |
| 4585 | penknife | |
| 4586 | pennant | |
| 4587 | penniless | |
| 4588 | penny | |
| 4589 | penpal | |
| 4590 | pension | |
| 4591 | pentagon | |
| 4592 | pentagram | |
| 4593 | pep | |
| 4594 | perceive | |
| 4595 | percent | |
| 4596 | perch | |
| 4597 | percolate | |
| 4598 | perennial | |
| 4599 | perfected | |
| 4600 | perfectly | |
| 4601 | perfume | |
| 4602 | periscope | |
| 4603 | perish | |
| 4604 | perjurer | |
| 4605 | perjury | |
| 4606 | perkiness | |
| 4607 | perky | |
| 4608 | perm | |
| 4609 | peroxide | |
| 4610 | perpetual | |
| 4611 | perplexed | |
| 4612 | persecute | |
| 4613 | persevere | |
| 4614 | persuaded | |
| 4615 | persuader | |
| 4616 | pesky | |
| 4617 | peso | |
| 4618 | pessimism | |
| 4619 | pessimist | |
| 4620 | pester | |
| 4621 | pesticide | |
| 4622 | petal | |
| 4623 | petite | |
| 4624 | petition | |
| 4625 | petri | |
| 4626 | petroleum | |
| 4627 | petted | |
| 4628 | petticoat | |
| 4629 | pettiness | |
| 4630 | petty | |
| 4631 | petunia | |
| 4632 | phantom | |
| 4633 | phobia | |
| 4634 | phoenix | |
| 4635 | phonebook | |
| 4636 | phoney | |
| 4637 | phonics | |
| 4638 | phoniness | |
| 4639 | phony | |
| 4640 | phosphate | |
| 4641 | photo | |
| 4642 | phrase | |
| 4643 | phrasing | |
| 4644 | placard | |
| 4645 | placate | |
| 4646 | placidly | |
| 4647 | plank | |
| 4648 | planner | |
| 4649 | plant | |
| 4650 | plasma | |
| 4651 | plaster | |
| 4652 | plastic | |
| 4653 | plated | |
| 4654 | platform | |
| 4655 | plating | |
| 4656 | platinum | |
| 4657 | platonic | |
| 4658 | platter | |
| 4659 | platypus | |
| 4660 | plausible | |
| 4661 | plausibly | |
| 4662 | playable | |
| 4663 | playback | |
| 4664 | player | |
| 4665 | playful | |
| 4666 | playgroup | |
| 4667 | playhouse | |
| 4668 | playing | |
| 4669 | playlist | |
| 4670 | playmaker | |
| 4671 | playmate | |
| 4672 | playoff | |
| 4673 | playpen | |
| 4674 | playroom | |
| 4675 | playset | |
| 4676 | plaything | |
| 4677 | playtime | |
| 4678 | plaza | |
| 4679 | pleading | |
| 4680 | pleat | |
| 4681 | pledge | |
| 4682 | plentiful | |
| 4683 | plenty | |
| 4684 | plethora | |
| 4685 | plexiglas | |
| 4686 | pliable | |
| 4687 | plod | |
| 4688 | plop | |
| 4689 | plot | |
| 4690 | plow | |
| 4691 | ploy | |
| 4692 | pluck | |
| 4693 | plug | |
| 4694 | plunder | |
| 4695 | plunging | |
| 4696 | plural | |
| 4697 | plus | |
| 4698 | plutonium | |
| 4699 | plywood | |
| 4700 | poach | |
| 4701 | pod | |
| 4702 | poem | |
| 4703 | poet | |
| 4704 | pogo | |
| 4705 | pointed | |
| 4706 | pointer | |
| 4707 | pointing | |
| 4708 | pointless | |
| 4709 | pointy | |
| 4710 | poise | |
| 4711 | poison | |
| 4712 | poker | |
| 4713 | poking | |
| 4714 | polar | |
| 4715 | police | |
| 4716 | policy | |
| 4717 | polio | |
| 4718 | polish | |
| 4719 | politely | |
| 4720 | polka | |
| 4721 | polo | |
| 4722 | polyester | |
| 4723 | polygon | |
| 4724 | polygraph | |
| 4725 | polymer | |
| 4726 | poncho | |
| 4727 | pond | |
| 4728 | pony | |
| 4729 | popcorn | |
| 4730 | pope | |
| 4731 | poplar | |
| 4732 | popper | |
| 4733 | poppy | |
| 4734 | popsicle | |
| 4735 | populace | |
| 4736 | popular | |
| 4737 | populate | |
| 4738 | porcupine | |
| 4739 | pork | |
| 4740 | porous | |
| 4741 | porridge | |
| 4742 | portable | |
| 4743 | portal | |
| 4744 | portfolio | |
| 4745 | porthole | |
| 4746 | portion | |
| 4747 | portly | |
| 4748 | portside | |
| 4749 | poser | |
| 4750 | posh | |
| 4751 | posing | |
| 4752 | possible | |
| 4753 | possibly | |
| 4754 | possum | |
| 4755 | postage | |
| 4756 | postal | |
| 4757 | postbox | |
| 4758 | postcard | |
| 4759 | posted | |
| 4760 | poster | |
| 4761 | posting | |
| 4762 | postnasal | |
| 4763 | posture | |
| 4764 | postwar | |
| 4765 | pouch | |
| 4766 | pounce | |
| 4767 | pouncing | |
| 4768 | pound | |
| 4769 | pouring | |
| 4770 | pout | |
| 4771 | powdered | |
| 4772 | powdering | |
| 4773 | powdery | |
| 4774 | power | |
| 4775 | powwow | |
| 4776 | pox | |
| 4777 | praising | |
| 4778 | prance | |
| 4779 | prancing | |
| 4780 | pranker | |
| 4781 | prankish | |
| 4782 | prankster | |
| 4783 | prayer | |
| 4784 | praying | |
| 4785 | preacher | |
| 4786 | preaching | |
| 4787 | preachy | |
| 4788 | preamble | |
| 4789 | precinct | |
| 4790 | precise | |
| 4791 | precision | |
| 4792 | precook | |
| 4793 | precut | |
| 4794 | predator | |
| 4795 | predefine | |
| 4796 | predict | |
| 4797 | preface | |
| 4798 | prefix | |
| 4799 | preflight | |
| 4800 | preformed | |
| 4801 | pregame | |
| 4802 | pregnancy | |
| 4803 | pregnant | |
| 4804 | preheated | |
| 4805 | prelaunch | |
| 4806 | prelaw | |
| 4807 | prelude | |
| 4808 | premiere | |
| 4809 | premises | |
| 4810 | premium | |
| 4811 | prenatal | |
| 4812 | preoccupy | |
| 4813 | preorder | |
| 4814 | prepaid | |
| 4815 | prepay | |
| 4816 | preplan | |
| 4817 | preppy | |
| 4818 | preschool | |
| 4819 | prescribe | |
| 4820 | preseason | |
| 4821 | preset | |
| 4822 | preshow | |
| 4823 | president | |
| 4824 | presoak | |
| 4825 | press | |
| 4826 | presume | |
| 4827 | presuming | |
| 4828 | preteen | |
| 4829 | pretended | |
| 4830 | pretender | |
| 4831 | pretense | |
| 4832 | pretext | |
| 4833 | pretty | |
| 4834 | pretzel | |
| 4835 | prevail | |
| 4836 | prevalent | |
| 4837 | prevent | |
| 4838 | preview | |
| 4839 | previous | |
| 4840 | prewar | |
| 4841 | prewashed | |
| 4842 | prideful | |
| 4843 | pried | |
| 4844 | primal | |
| 4845 | primarily | |
| 4846 | primary | |
| 4847 | primate | |
| 4848 | primer | |
| 4849 | primp | |
| 4850 | princess | |
| 4851 | ||
| 4852 | prior | |
| 4853 | prism | |
| 4854 | prison | |
| 4855 | prissy | |
| 4856 | pristine | |
| 4857 | privacy | |
| 4858 | private | |
| 4859 | privatize | |
| 4860 | prize | |
| 4861 | proactive | |
| 4862 | probable | |
| 4863 | probably | |
| 4864 | probation | |
| 4865 | probe | |
| 4866 | probing | |
| 4867 | probiotic | |
| 4868 | problem | |
| 4869 | procedure | |
| 4870 | process | |
| 4871 | proclaim | |
| 4872 | procreate | |
| 4873 | procurer | |
| 4874 | prodigal | |
| 4875 | prodigy | |
| 4876 | produce | |
| 4877 | product | |
| 4878 | profane | |
| 4879 | profanity | |
| 4880 | professed | |
| 4881 | professor | |
| 4882 | profile | |
| 4883 | profound | |
| 4884 | profusely | |
| 4885 | progeny | |
| 4886 | prognosis | |
| 4887 | program | |
| 4888 | progress | |
| 4889 | projector | |
| 4890 | prologue | |
| 4891 | prolonged | |
| 4892 | promenade | |
| 4893 | prominent | |
| 4894 | promoter | |
| 4895 | promotion | |
| 4896 | prompter | |
| 4897 | promptly | |
| 4898 | prone | |
| 4899 | prong | |
| 4900 | pronounce | |
| 4901 | pronto | |
| 4902 | proofing | |
| 4903 | proofread | |
| 4904 | proofs | |
| 4905 | propeller | |
| 4906 | properly | |
| 4907 | property | |
| 4908 | proponent | |
| 4909 | proposal | |
| 4910 | propose | |
| 4911 | props | |
| 4912 | prorate | |
| 4913 | protector | |
| 4914 | protegee | |
| 4915 | proton | |
| 4916 | prototype | |
| 4917 | protozoan | |
| 4918 | protract | |
| 4919 | protrude | |
| 4920 | proud | |
| 4921 | provable | |
| 4922 | proved | |
| 4923 | proven | |
| 4924 | provided | |
| 4925 | provider | |
| 4926 | providing | |
| 4927 | province | |
| 4928 | proving | |
| 4929 | provoke | |
| 4930 | provoking | |
| 4931 | provolone | |
| 4932 | prowess | |
| 4933 | prowler | |
| 4934 | prowling | |
| 4935 | proximity | |
| 4936 | proxy | |
| 4937 | prozac | |
| 4938 | prude | |
| 4939 | prudishly | |
| 4940 | prune | |
| 4941 | pruning | |
| 4942 | pry | |
| 4943 | psychic | |
| 4944 | public | |
| 4945 | publisher | |
| 4946 | pucker | |
| 4947 | pueblo | |
| 4948 | pug | |
| 4949 | pull | |
| 4950 | pulmonary | |
| 4951 | pulp | |
| 4952 | pulsate | |
| 4953 | pulse | |
| 4954 | pulverize | |
| 4955 | puma | |
| 4956 | pumice | |
| 4957 | pummel | |
| 4958 | punch | |
| 4959 | punctual | |
| 4960 | punctuate | |
| 4961 | punctured | |
| 4962 | pungent | |
| 4963 | punisher | |
| 4964 | punk | |
| 4965 | pupil | |
| 4966 | puppet | |
| 4967 | puppy | |
| 4968 | purchase | |
| 4969 | pureblood | |
| 4970 | purebred | |
| 4971 | purely | |
| 4972 | pureness | |
| 4973 | purgatory | |
| 4974 | purge | |
| 4975 | purging | |
| 4976 | purifier | |
| 4977 | purify | |
| 4978 | purist | |
| 4979 | puritan | |
| 4980 | purity | |
| 4981 | purple | |
| 4982 | purplish | |
| 4983 | purposely | |
| 4984 | purr | |
| 4985 | purse | |
| 4986 | pursuable | |
| 4987 | pursuant | |
| 4988 | pursuit | |
| 4989 | purveyor | |
| 4990 | pushcart | |
| 4991 | pushchair | |
| 4992 | pusher | |
| 4993 | pushiness | |
| 4994 | pushing | |
| 4995 | pushover | |
| 4996 | pushpin | |
| 4997 | pushup | |
| 4998 | pushy | |
| 4999 | putdown | |
| 5000 | putt | |
| 5001 | puzzle | |
| 5002 | puzzling | |
| 5003 | pyramid | |
| 5004 | pyromania | |
| 5005 | python | |
| 5006 | quack | |
| 5007 | quadrant | |
| 5008 | quail | |
| 5009 | quaintly | |
| 5010 | quake | |
| 5011 | quaking | |
| 5012 | qualified | |
| 5013 | qualifier | |
| 5014 | qualify | |
| 5015 | quality | |
| 5016 | qualm | |
| 5017 | quantum | |
| 5018 | quarrel | |
| 5019 | quarry | |
| 5020 | quartered | |
| 5021 | quarterly | |
| 5022 | quarters | |
| 5023 | quartet | |
| 5024 | quench | |
| 5025 | query | |
| 5026 | quicken | |
| 5027 | quickly | |
| 5028 | quickness | |
| 5029 | quicksand | |
| 5030 | quickstep | |
| 5031 | quiet | |
| 5032 | quill | |
| 5033 | quilt | |
| 5034 | quintet | |
| 5035 | quintuple | |
| 5036 | quirk | |
| 5037 | quit | |
| 5038 | quiver | |
| 5039 | quizzical | |
| 5040 | quotable | |
| 5041 | quotation | |
| 5042 | quote | |
| 5043 | rabid | |
| 5044 | race | |
| 5045 | racing | |
| 5046 | racism | |
| 5047 | rack | |
| 5048 | racoon | |
| 5049 | radar | |
| 5050 | radial | |
| 5051 | radiance | |
| 5052 | radiantly | |
| 5053 | radiated | |
| 5054 | radiation | |
| 5055 | radiator | |
| 5056 | radio | |
| 5057 | radish | |
| 5058 | raffle | |
| 5059 | raft | |
| 5060 | rage | |
| 5061 | ragged | |
| 5062 | raging | |
| 5063 | ragweed | |
| 5064 | raider | |
| 5065 | railcar | |
| 5066 | railing | |
| 5067 | railroad | |
| 5068 | railway | |
| 5069 | raisin | |
| 5070 | rake | |
| 5071 | raking | |
| 5072 | rally | |
| 5073 | ramble | |
| 5074 | rambling | |
| 5075 | ramp | |
| 5076 | ramrod | |
| 5077 | ranch | |
| 5078 | rancidity | |
| 5079 | random | |
| 5080 | ranged | |
| 5081 | ranger | |
| 5082 | ranging | |
| 5083 | ranked | |
| 5084 | ranking | |
| 5085 | ransack | |
| 5086 | ranting | |
| 5087 | rants | |
| 5088 | rare | |
| 5089 | rarity | |
| 5090 | rascal | |
| 5091 | rash | |
| 5092 | rasping | |
| 5093 | ravage | |
| 5094 | raven | |
| 5095 | ravine | |
| 5096 | raving | |
| 5097 | ravioli | |
| 5098 | ravishing | |
| 5099 | reabsorb | |
| 5100 | reach | |
| 5101 | reacquire | |
| 5102 | reaction | |
| 5103 | reactive | |
| 5104 | reactor | |
| 5105 | reaffirm | |
| 5106 | ream | |
| 5107 | reanalyze | |
| 5108 | reappear | |
| 5109 | reapply | |
| 5110 | reappoint | |
| 5111 | reapprove | |
| 5112 | rearrange | |
| 5113 | rearview | |
| 5114 | reason | |
| 5115 | reassign | |
| 5116 | reassure | |
| 5117 | reattach | |
| 5118 | reawake | |
| 5119 | rebalance | |
| 5120 | rebate | |
| 5121 | rebel | |
| 5122 | rebirth | |
| 5123 | reboot | |
| 5124 | reborn | |
| 5125 | rebound | |
| 5126 | rebuff | |
| 5127 | rebuild | |
| 5128 | rebuilt | |
| 5129 | reburial | |
| 5130 | rebuttal | |
| 5131 | recall | |
| 5132 | recant | |
| 5133 | recapture | |
| 5134 | recast | |
| 5135 | recede | |
| 5136 | recent | |
| 5137 | recess | |
| 5138 | recharger | |
| 5139 | recipient | |
| 5140 | recital | |
| 5141 | recite | |
| 5142 | reckless | |
| 5143 | reclaim | |
| 5144 | recliner | |
| 5145 | reclining | |
| 5146 | recluse | |
| 5147 | reclusive | |
| 5148 | recognize | |
| 5149 | recoil | |
| 5150 | recollect | |
| 5151 | recolor | |
| 5152 | reconcile | |
| 5153 | reconfirm | |
| 5154 | reconvene | |
| 5155 | recopy | |
| 5156 | record | |
| 5157 | recount | |
| 5158 | recoup | |
| 5159 | recovery | |
| 5160 | recreate | |
| 5161 | rectal | |
| 5162 | rectangle | |
| 5163 | rectified | |
| 5164 | rectify | |
| 5165 | recycled | |
| 5166 | recycler | |
| 5167 | recycling | |
| 5168 | reemerge | |
| 5169 | reenact | |
| 5170 | reenter | |
| 5171 | reentry | |
| 5172 | reexamine | |
| 5173 | referable | |
| 5174 | referee | |
| 5175 | reference | |
| 5176 | refill | |
| 5177 | refinance | |
| 5178 | refined | |
| 5179 | refinery | |
| 5180 | refining | |
| 5181 | refinish | |
| 5182 | reflected | |
| 5183 | reflector | |
| 5184 | reflex | |
| 5185 | reflux | |
| 5186 | refocus | |
| 5187 | refold | |
| 5188 | reforest | |
| 5189 | reformat | |
| 5190 | reformed | |
| 5191 | reformer | |
| 5192 | reformist | |
| 5193 | refract | |
| 5194 | refrain | |
| 5195 | refreeze | |
| 5196 | refresh | |
| 5197 | refried | |
| 5198 | refueling | |
| 5199 | refund | |
| 5200 | refurbish | |
| 5201 | refurnish | |
| 5202 | refusal | |
| 5203 | refuse | |
| 5204 | refusing | |
| 5205 | refutable | |
| 5206 | refute | |
| 5207 | regain | |
| 5208 | regalia | |
| 5209 | regally | |
| 5210 | reggae | |
| 5211 | regime | |
| 5212 | region | |
| 5213 | register | |
| 5214 | registrar | |
| 5215 | registry | |
| 5216 | regress | |
| 5217 | regretful | |
| 5218 | regroup | |
| 5219 | regular | |
| 5220 | regulate | |
| 5221 | regulator | |
| 5222 | rehab | |
| 5223 | reheat | |
| 5224 | rehire | |
| 5225 | rehydrate | |
| 5226 | reimburse | |
| 5227 | reissue | |
| 5228 | reiterate | |
| 5229 | rejoice | |
| 5230 | rejoicing | |
| 5231 | rejoin | |
| 5232 | rekindle | |
| 5233 | relapse | |
| 5234 | relapsing | |
| 5235 | relatable | |
| 5236 | related | |
| 5237 | relation | |
| 5238 | relative | |
| 5239 | relax | |
| 5240 | relay | |
| 5241 | relearn | |
| 5242 | release | |
| 5243 | relenting | |
| 5244 | reliable | |
| 5245 | reliably | |
| 5246 | reliance | |
| 5247 | reliant | |
| 5248 | relic | |
| 5249 | relieve | |
| 5250 | relieving | |
| 5251 | relight | |
| 5252 | relish | |
| 5253 | relive | |
| 5254 | reload | |
| 5255 | relocate | |
| 5256 | relock | |
| 5257 | reluctant | |
| 5258 | rely | |
| 5259 | remake | |
| 5260 | remark | |
| 5261 | remarry | |
| 5262 | rematch | |
| 5263 | remedial | |
| 5264 | remedy | |
| 5265 | remember | |
| 5266 | reminder | |
| 5267 | remindful | |
| 5268 | remission | |
| 5269 | remix | |
| 5270 | remnant | |
| 5271 | remodeler | |
| 5272 | remold | |
| 5273 | remorse | |
| 5274 | remote | |
| 5275 | removable | |
| 5276 | removal | |
| 5277 | removed | |
| 5278 | remover | |
| 5279 | removing | |
| 5280 | rename | |
| 5281 | renderer | |
| 5282 | rendering | |
| 5283 | rendition | |
| 5284 | renegade | |
| 5285 | renewable | |
| 5286 | renewably | |
| 5287 | renewal | |
| 5288 | renewed | |
| 5289 | renounce | |
| 5290 | renovate | |
| 5291 | renovator | |
| 5292 | rentable | |
| 5293 | rental | |
| 5294 | rented | |
| 5295 | renter | |
| 5296 | reoccupy | |
| 5297 | reoccur | |
| 5298 | reopen | |
| 5299 | reorder | |
| 5300 | repackage | |
| 5301 | repacking | |
| 5302 | repaint | |
| 5303 | repair | |
| 5304 | repave | |
| 5305 | repaying | |
| 5306 | repayment | |
| 5307 | repeal | |
| 5308 | repeated | |
| 5309 | repeater | |
| 5310 | repent | |
| 5311 | rephrase | |
| 5312 | replace | |
| 5313 | replay | |
| 5314 | replica | |
| 5315 | reply | |
| 5316 | reporter | |
| 5317 | repose | |
| 5318 | repossess | |
| 5319 | repost | |
| 5320 | repressed | |
| 5321 | reprimand | |
| 5322 | reprint | |
| 5323 | reprise | |
| 5324 | reproach | |
| 5325 | reprocess | |
| 5326 | reproduce | |
| 5327 | reprogram | |
| 5328 | reps | |
| 5329 | reptile | |
| 5330 | reptilian | |
| 5331 | repugnant | |
| 5332 | repulsion | |
| 5333 | repulsive | |
| 5334 | repurpose | |
| 5335 | reputable | |
| 5336 | reputably | |
| 5337 | request | |
| 5338 | require | |
| 5339 | requisite | |
| 5340 | reroute | |
| 5341 | rerun | |
| 5342 | resale | |
| 5343 | resample | |
| 5344 | rescuer | |
| 5345 | reseal | |
| 5346 | research | |
| 5347 | reselect | |
| 5348 | reseller | |
| 5349 | resemble | |
| 5350 | resend | |
| 5351 | resent | |
| 5352 | reset | |
| 5353 | reshape | |
| 5354 | reshoot | |
| 5355 | reshuffle | |
| 5356 | residence | |
| 5357 | residency | |
| 5358 | resident | |
| 5359 | residual | |
| 5360 | residue | |
| 5361 | resigned | |
| 5362 | resilient | |
| 5363 | resistant | |
| 5364 | resisting | |
| 5365 | resize | |
| 5366 | resolute | |
| 5367 | resolved | |
| 5368 | resonant | |
| 5369 | resonate | |
| 5370 | resort | |
| 5371 | resource | |
| 5372 | respect | |
| 5373 | resubmit | |
| 5374 | result | |
| 5375 | resume | |
| 5376 | resupply | |
| 5377 | resurface | |
| 5378 | resurrect | |
| 5379 | retail | |
| 5380 | retainer | |
| 5381 | retaining | |
| 5382 | retake | |
| 5383 | retaliate | |
| 5384 | retention | |
| 5385 | rethink | |
| 5386 | retinal | |
| 5387 | retired | |
| 5388 | retiree | |
| 5389 | retiring | |
| 5390 | retold | |
| 5391 | retool | |
| 5392 | retorted | |
| 5393 | retouch | |
| 5394 | retrace | |
| 5395 | retract | |
| 5396 | retrain | |
| 5397 | retread | |
| 5398 | retreat | |
| 5399 | retrial | |
| 5400 | retrieval | |
| 5401 | retriever | |
| 5402 | retry | |
| 5403 | return | |
| 5404 | retying | |
| 5405 | retype | |
| 5406 | reunion | |
| 5407 | reunite | |
| 5408 | reusable | |
| 5409 | reuse | |
| 5410 | reveal | |
| 5411 | reveler | |
| 5412 | revenge | |
| 5413 | revenue | |
| 5414 | reverb | |
| 5415 | revered | |
| 5416 | reverence | |
| 5417 | reverend | |
| 5418 | reversal | |
| 5419 | reverse | |
| 5420 | reversing | |
| 5421 | reversion | |
| 5422 | revert | |
| 5423 | revisable | |
| 5424 | revise | |
| 5425 | revision | |
| 5426 | revisit | |
| 5427 | revivable | |
| 5428 | revival | |
| 5429 | reviver | |
| 5430 | reviving | |
| 5431 | revocable | |
| 5432 | revoke | |
| 5433 | revolt | |
| 5434 | revolver | |
| 5435 | revolving | |
| 5436 | reward | |
| 5437 | rewash | |
| 5438 | rewind | |
| 5439 | rewire | |
| 5440 | reword | |
| 5441 | rework | |
| 5442 | rewrap | |
| 5443 | rewrite | |
| 5444 | rhyme | |
| 5445 | ribbon | |
| 5446 | ribcage | |
| 5447 | rice | |
| 5448 | riches | |
| 5449 | richly | |
| 5450 | richness | |
| 5451 | rickety | |
| 5452 | ricotta | |
| 5453 | riddance | |
| 5454 | ridden | |
| 5455 | ride | |
| 5456 | riding | |
| 5457 | rifling | |
| 5458 | rift | |
| 5459 | rigging | |
| 5460 | rigid | |
| 5461 | rigor | |
| 5462 | rimless | |
| 5463 | rimmed | |
| 5464 | rind | |
| 5465 | rink | |
| 5466 | rinse | |
| 5467 | rinsing | |
| 5468 | riot | |
| 5469 | ripcord | |
| 5470 | ripeness | |
| 5471 | ripening | |
| 5472 | ripping | |
| 5473 | ripple | |
| 5474 | rippling | |
| 5475 | riptide | |
| 5476 | rise | |
| 5477 | rising | |
| 5478 | risk | |
| 5479 | risotto | |
| 5480 | ritalin | |
| 5481 | ritzy | |
| 5482 | rival | |
| 5483 | riverbank | |
| 5484 | riverbed | |
| 5485 | riverboat | |
| 5486 | riverside | |
| 5487 | riveter | |
| 5488 | riveting | |
| 5489 | roamer | |
| 5490 | roaming | |
| 5491 | roast | |
| 5492 | robbing | |
| 5493 | robe | |
| 5494 | robin | |
| 5495 | robotics | |
| 5496 | robust | |
| 5497 | rockband | |
| 5498 | rocker | |
| 5499 | rocket | |
| 5500 | rockfish | |
| 5501 | rockiness | |
| 5502 | rocking | |
| 5503 | rocklike | |
| 5504 | rockslide | |
| 5505 | rockstar | |
| 5506 | rocky | |
| 5507 | rogue | |
| 5508 | roman | |
| 5509 | romp | |
| 5510 | rope | |
| 5511 | roping | |
| 5512 | roster | |
| 5513 | rosy | |
| 5514 | rotten | |
| 5515 | rotting | |
| 5516 | rotunda | |
| 5517 | roulette | |
| 5518 | rounding | |
| 5519 | roundish | |
| 5520 | roundness | |
| 5521 | roundup | |
| 5522 | roundworm | |
| 5523 | routine | |
| 5524 | routing | |
| 5525 | rover | |
| 5526 | roving | |
| 5527 | royal | |
| 5528 | rubbed | |
| 5529 | rubber | |
| 5530 | rubbing | |
| 5531 | rubble | |
| 5532 | rubdown | |
| 5533 | ruby | |
| 5534 | ruckus | |
| 5535 | rudder | |
| 5536 | rug | |
| 5537 | ruined | |
| 5538 | rule | |
| 5539 | rumble | |
| 5540 | rumbling | |
| 5541 | rummage | |
| 5542 | rumor | |
| 5543 | runaround | |
| 5544 | rundown | |
| 5545 | runner | |
| 5546 | running | |
| 5547 | runny | |
| 5548 | runt | |
| 5549 | runway | |
| 5550 | rupture | |
| 5551 | rural | |
| 5552 | ruse | |
| 5553 | rush | |
| 5554 | rust | |
| 5555 | rut | |
| 5556 | sabbath | |
| 5557 | sabotage | |
| 5558 | sacrament | |
| 5559 | sacred | |
| 5560 | sacrifice | |
| 5561 | sadden | |
| 5562 | saddlebag | |
| 5563 | saddled | |
| 5564 | saddling | |
| 5565 | sadly | |
| 5566 | sadness | |
| 5567 | safari | |
| 5568 | safeguard | |
| 5569 | safehouse | |
| 5570 | safely | |
| 5571 | safeness | |
| 5572 | saffron | |
| 5573 | saga | |
| 5574 | sage | |
| 5575 | sagging | |
| 5576 | saggy | |
| 5577 | said | |
| 5578 | saint | |
| 5579 | sake | |
| 5580 | salad | |
| 5581 | salami | |
| 5582 | salaried | |
| 5583 | salary | |
| 5584 | saline | |
| 5585 | salon | |
| 5586 | saloon | |
| 5587 | salsa | |
| 5588 | salt | |
| 5589 | salutary | |
| 5590 | salute | |
| 5591 | salvage | |
| 5592 | salvaging | |
| 5593 | salvation | |
| 5594 | same | |
| 5595 | sample | |
| 5596 | sampling | |
| 5597 | sanction | |
| 5598 | sanctity | |
| 5599 | sanctuary | |
| 5600 | sandal | |
| 5601 | sandbag | |
| 5602 | sandbank | |
| 5603 | sandbar | |
| 5604 | sandblast | |
| 5605 | sandbox | |
| 5606 | sanded | |
| 5607 | sandfish | |
| 5608 | sanding | |
| 5609 | sandlot | |
| 5610 | sandpaper | |
| 5611 | sandpit | |
| 5612 | sandstone | |
| 5613 | sandstorm | |
| 5614 | sandworm | |
| 5615 | sandy | |
| 5616 | sanitary | |
| 5617 | sanitizer | |
| 5618 | sank | |
| 5619 | santa | |
| 5620 | sapling | |
| 5621 | sappiness | |
| 5622 | sappy | |
| 5623 | sarcasm | |
| 5624 | sarcastic | |
| 5625 | sardine | |
| 5626 | sash | |
| 5627 | sasquatch | |
| 5628 | sassy | |
| 5629 | satchel | |
| 5630 | satiable | |
| 5631 | satin | |
| 5632 | satirical | |
| 5633 | satisfied | |
| 5634 | satisfy | |
| 5635 | saturate | |
| 5636 | saturday | |
| 5637 | sauciness | |
| 5638 | saucy | |
| 5639 | sauna | |
| 5640 | savage | |
| 5641 | savanna | |
| 5642 | saved | |
| 5643 | savings | |
| 5644 | savior | |
| 5645 | savor | |
| 5646 | saxophone | |
| 5647 | say | |
| 5648 | scabbed | |
| 5649 | scabby | |
| 5650 | scalded | |
| 5651 | scalding | |
| 5652 | scale | |
| 5653 | scaling | |
| 5654 | scallion | |
| 5655 | scallop | |
| 5656 | scalping | |
| 5657 | scam | |
| 5658 | scandal | |
| 5659 | scanner | |
| 5660 | scanning | |
| 5661 | scant | |
| 5662 | scapegoat | |
| 5663 | scarce | |
| 5664 | scarcity | |
| 5665 | scarecrow | |
| 5666 | scared | |
| 5667 | scarf | |
| 5668 | scarily | |
| 5669 | scariness | |
| 5670 | scarring | |
| 5671 | scary | |
| 5672 | scavenger | |
| 5673 | scenic | |
| 5674 | schedule | |
| 5675 | schematic | |
| 5676 | scheme | |
| 5677 | scheming | |
| 5678 | schilling | |
| 5679 | schnapps | |
| 5680 | scholar | |
| 5681 | science | |
| 5682 | scientist | |
| 5683 | scion | |
| 5684 | scoff | |
| 5685 | scolding | |
| 5686 | scone | |
| 5687 | scoop | |
| 5688 | scooter | |
| 5689 | scope | |
| 5690 | scorch | |
| 5691 | scorebook | |
| 5692 | scorecard | |
| 5693 | scored | |
| 5694 | scoreless | |
| 5695 | scorer | |
| 5696 | scoring | |
| 5697 | scorn | |
| 5698 | scorpion | |
| 5699 | scotch | |
| 5700 | scoundrel | |
| 5701 | scoured | |
| 5702 | scouring | |
| 5703 | scouting | |
| 5704 | scouts | |
| 5705 | scowling | |
| 5706 | scrabble | |
| 5707 | scraggly | |
| 5708 | scrambled | |
| 5709 | scrambler | |
| 5710 | scrap | |
| 5711 | scratch | |
| 5712 | scrawny | |
| 5713 | screen | |
| 5714 | scribble | |
| 5715 | scribe | |
| 5716 | scribing | |
| 5717 | scrimmage | |
| 5718 | script | |
| 5719 | scroll | |
| 5720 | scrooge | |
| 5721 | scrounger | |
| 5722 | scrubbed | |
| 5723 | scrubber | |
| 5724 | scruffy | |
| 5725 | scrunch | |
| 5726 | scrutiny | |
| 5727 | scuba | |
| 5728 | scuff | |
| 5729 | sculptor | |
| 5730 | sculpture | |
| 5731 | scurvy | |
| 5732 | scuttle | |
| 5733 | secluded | |
| 5734 | secluding | |
| 5735 | seclusion | |
| 5736 | second | |
| 5737 | secrecy | |
| 5738 | secret | |
| 5739 | sectional | |
| 5740 | sector | |
| 5741 | secular | |
| 5742 | securely | |
| 5743 | security | |
| 5744 | sedan | |
| 5745 | sedate | |
| 5746 | sedation | |
| 5747 | sedative | |
| 5748 | sediment | |
| 5749 | seduce | |
| 5750 | seducing | |
| 5751 | segment | |
| 5752 | seismic | |
| 5753 | seizing | |
| 5754 | seldom | |
| 5755 | selected | |
| 5756 | selection | |
| 5757 | selective | |
| 5758 | selector | |
| 5759 | self | |
| 5760 | seltzer | |
| 5761 | semantic | |
| 5762 | semester | |
| 5763 | semicolon | |
| 5764 | semifinal | |
| 5765 | seminar | |
| 5766 | semisoft | |
| 5767 | semisweet | |
| 5768 | senate | |
| 5769 | senator | |
| 5770 | send | |
| 5771 | senior | |
| 5772 | senorita | |
| 5773 | sensation | |
| 5774 | sensitive | |
| 5775 | sensitize | |
| 5776 | sensually | |
| 5777 | sensuous | |
| 5778 | sepia | |
| 5779 | september | |
| 5780 | septic | |
| 5781 | septum | |
| 5782 | sequel | |
| 5783 | sequence | |
| 5784 | sequester | |
| 5785 | series | |
| 5786 | sermon | |
| 5787 | serotonin | |
| 5788 | serpent | |
| 5789 | serrated | |
| 5790 | serve | |
| 5791 | service | |
| 5792 | serving | |
| 5793 | sesame | |
| 5794 | sessions | |
| 5795 | setback | |
| 5796 | setting | |
| 5797 | settle | |
| 5798 | settling | |
| 5799 | setup | |
| 5800 | sevenfold | |
| 5801 | seventeen | |
| 5802 | seventh | |
| 5803 | seventy | |
| 5804 | severity | |
| 5805 | shabby | |
| 5806 | shack | |
| 5807 | shaded | |
| 5808 | shadily | |
| 5809 | shadiness | |
| 5810 | shading | |
| 5811 | shadow | |
| 5812 | shady | |
| 5813 | shaft | |
| 5814 | shakable | |
| 5815 | shakily | |
| 5816 | shakiness | |
| 5817 | shaking | |
| 5818 | shaky | |
| 5819 | shale | |
| 5820 | shallot | |
| 5821 | shallow | |
| 5822 | shame | |
| 5823 | shampoo | |
| 5824 | shamrock | |
| 5825 | shank | |
| 5826 | shanty | |
| 5827 | shape | |
| 5828 | shaping | |
| 5829 | share | |
| 5830 | sharpener | |
| 5831 | sharper | |
| 5832 | sharpie | |
| 5833 | sharply | |
| 5834 | sharpness | |
| 5835 | shawl | |
| 5836 | sheath | |
| 5837 | shed | |
| 5838 | sheep | |
| 5839 | sheet | |
| 5840 | shelf | |
| 5841 | shell | |
| 5842 | shelter | |
| 5843 | shelve | |
| 5844 | shelving | |
| 5845 | sherry | |
| 5846 | shield | |
| 5847 | shifter | |
| 5848 | shifting | |
| 5849 | shiftless | |
| 5850 | shifty | |
| 5851 | shimmer | |
| 5852 | shimmy | |
| 5853 | shindig | |
| 5854 | shine | |
| 5855 | shingle | |
| 5856 | shininess | |
| 5857 | shining | |
| 5858 | shiny | |
| 5859 | ship | |
| 5860 | shirt | |
| 5861 | shivering | |
| 5862 | shock | |
| 5863 | shone | |
| 5864 | shoplift | |
| 5865 | shopper | |
| 5866 | shopping | |
| 5867 | shoptalk | |
| 5868 | shore | |
| 5869 | shortage | |
| 5870 | shortcake | |
| 5871 | shortcut | |
| 5872 | shorten | |
| 5873 | shorter | |
| 5874 | shorthand | |
| 5875 | shortlist | |
| 5876 | shortly | |
| 5877 | shortness | |
| 5878 | shorts | |
| 5879 | shortwave | |
| 5880 | shorty | |
| 5881 | shout | |
| 5882 | shove | |
| 5883 | showbiz | |
| 5884 | showcase | |
| 5885 | showdown | |
| 5886 | shower | |
| 5887 | showgirl | |
| 5888 | showing | |
| 5889 | showman | |
| 5890 | shown | |
| 5891 | showoff | |
| 5892 | showpiece | |
| 5893 | showplace | |
| 5894 | showroom | |
| 5895 | showy | |
| 5896 | shrank | |
| 5897 | shrapnel | |
| 5898 | shredder | |
| 5899 | shredding | |
| 5900 | shrewdly | |
| 5901 | shriek | |
| 5902 | shrill | |
| 5903 | shrimp | |
| 5904 | shrine | |
| 5905 | shrink | |
| 5906 | shrivel | |
| 5907 | shrouded | |
| 5908 | shrubbery | |
| 5909 | shrubs | |
| 5910 | shrug | |
| 5911 | shrunk | |
| 5912 | shucking | |
| 5913 | shudder | |
| 5914 | shuffle | |
| 5915 | shuffling | |
| 5916 | shun | |
| 5917 | shush | |
| 5918 | shut | |
| 5919 | shy | |
| 5920 | siamese | |
| 5921 | siberian | |
| 5922 | sibling | |
| 5923 | siding | |
| 5924 | sierra | |
| 5925 | siesta | |
| 5926 | sift | |
| 5927 | sighing | |
| 5928 | silenced | |
| 5929 | silencer | |
| 5930 | silent | |
| 5931 | silica | |
| 5932 | silicon | |
| 5933 | silk | |
| 5934 | silliness | |
| 5935 | silly | |
| 5936 | silo | |
| 5937 | silt | |
| 5938 | silver | |
| 5939 | similarly | |
| 5940 | simile | |
| 5941 | simmering | |
| 5942 | simple | |
| 5943 | simplify | |
| 5944 | simply | |
| 5945 | sincere | |
| 5946 | sincerity | |
| 5947 | singer | |
| 5948 | singing | |
| 5949 | single | |
| 5950 | singular | |
| 5951 | sinister | |
| 5952 | sinless | |
| 5953 | sinner | |
| 5954 | sinuous | |
| 5955 | sip | |
| 5956 | siren | |
| 5957 | sister | |
| 5958 | sitcom | |
| 5959 | sitter | |
| 5960 | sitting | |
| 5961 | situated | |
| 5962 | situation | |
| 5963 | sixfold | |
| 5964 | sixteen | |
| 5965 | sixth | |
| 5966 | sixties | |
| 5967 | sixtieth | |
| 5968 | sixtyfold | |
| 5969 | sizable | |
| 5970 | sizably | |
| 5971 | size | |
| 5972 | sizing | |
| 5973 | sizzle | |
| 5974 | sizzling | |
| 5975 | skater | |
| 5976 | skating | |
| 5977 | skedaddle | |
| 5978 | skeletal | |
| 5979 | skeleton | |
| 5980 | skeptic | |
| 5981 | sketch | |
| 5982 | skewed | |
| 5983 | skewer | |
| 5984 | skid | |
| 5985 | skied | |
| 5986 | skier | |
| 5987 | skies | |
| 5988 | skiing | |
| 5989 | skilled | |
| 5990 | skillet | |
| 5991 | skillful | |
| 5992 | skimmed | |
| 5993 | skimmer | |
| 5994 | skimming | |
| 5995 | skimpily | |
| 5996 | skincare | |
| 5997 | skinhead | |
| 5998 | skinless | |
| 5999 | skinning | |
| 6000 | skinny | |
| 6001 | skintight | |
| 6002 | skipper | |
| 6003 | skipping | |
| 6004 | skirmish | |
| 6005 | skirt | |
| 6006 | skittle | |
| 6007 | skydiver | |
| 6008 | skylight | |
| 6009 | skyline | |
| 6010 | skype | |
| 6011 | skyrocket | |
| 6012 | skyward | |
| 6013 | slab | |
| 6014 | slacked | |
| 6015 | slacker | |
| 6016 | slacking | |
| 6017 | slackness | |
| 6018 | slacks | |
| 6019 | slain | |
| 6020 | slam | |
| 6021 | slander | |
| 6022 | slang | |
| 6023 | slapping | |
| 6024 | slapstick | |
| 6025 | slashed | |
| 6026 | slashing | |
| 6027 | slate | |
| 6028 | slather | |
| 6029 | slaw | |
| 6030 | sled | |
| 6031 | sleek | |
| 6032 | sleep | |
| 6033 | sleet | |
| 6034 | sleeve | |
| 6035 | slept | |
| 6036 | sliceable | |
| 6037 | sliced | |
| 6038 | slicer | |
| 6039 | slicing | |
| 6040 | slick | |
| 6041 | slider | |
| 6042 | slideshow | |
| 6043 | sliding | |
| 6044 | slighted | |
| 6045 | slighting | |
| 6046 | slightly | |
| 6047 | slimness | |
| 6048 | slimy | |
| 6049 | slinging | |
| 6050 | slingshot | |
| 6051 | slinky | |
| 6052 | slip | |
| 6053 | slit | |
| 6054 | sliver | |
| 6055 | slobbery | |
| 6056 | slogan | |
| 6057 | sloped | |
| 6058 | sloping | |
| 6059 | sloppily | |
| 6060 | sloppy | |
| 6061 | slot | |
| 6062 | slouching | |
| 6063 | slouchy | |
| 6064 | sludge | |
| 6065 | slug | |
| 6066 | slum | |
| 6067 | slurp | |
| 6068 | slush | |
| 6069 | sly | |
| 6070 | small | |
| 6071 | smartly | |
| 6072 | smartness | |
| 6073 | smasher | |
| 6074 | smashing | |
| 6075 | smashup | |
| 6076 | smell | |
| 6077 | smelting | |
| 6078 | smile | |
| 6079 | smilingly | |
| 6080 | smirk | |
| 6081 | smite | |
| 6082 | smith | |
| 6083 | smitten | |
| 6084 | smock | |
| 6085 | smog | |
| 6086 | smoked | |
| 6087 | smokeless | |
| 6088 | smokiness | |
| 6089 | smoking | |
| 6090 | smoky | |
| 6091 | smolder | |
| 6092 | smooth | |
| 6093 | smother | |
| 6094 | smudge | |
| 6095 | smudgy | |
| 6096 | smuggler | |
| 6097 | smuggling | |
| 6098 | smugly | |
| 6099 | smugness | |
| 6100 | snack | |
| 6101 | snagged | |
| 6102 | snaking | |
| 6103 | snap | |
| 6104 | snare | |
| 6105 | snarl | |
| 6106 | snazzy | |
| 6107 | sneak | |
| 6108 | sneer | |
| 6109 | sneeze | |
| 6110 | sneezing | |
| 6111 | snide | |
| 6112 | sniff | |
| 6113 | snippet | |
| 6114 | snipping | |
| 6115 | snitch | |
| 6116 | snooper | |
| 6117 | snooze | |
| 6118 | snore | |
| 6119 | snoring | |
| 6120 | snorkel | |
| 6121 | snort | |
| 6122 | snout | |
| 6123 | snowbird | |
| 6124 | snowboard | |
| 6125 | snowbound | |
| 6126 | snowcap | |
| 6127 | snowdrift | |
| 6128 | snowdrop | |
| 6129 | snowfall | |
| 6130 | snowfield | |
| 6131 | snowflake | |
| 6132 | snowiness | |
| 6133 | snowless | |
| 6134 | snowman | |
| 6135 | snowplow | |
| 6136 | snowshoe | |
| 6137 | snowstorm | |
| 6138 | snowsuit | |
| 6139 | snowy | |
| 6140 | snub | |
| 6141 | snuff | |
| 6142 | snuggle | |
| 6143 | snugly | |
| 6144 | snugness | |
| 6145 | speak | |
| 6146 | spearfish | |
| 6147 | spearhead | |
| 6148 | spearman | |
| 6149 | spearmint | |
| 6150 | species | |
| 6151 | specimen | |
| 6152 | specked | |
| 6153 | speckled | |
| 6154 | specks | |
| 6155 | spectacle | |
| 6156 | spectator | |
| 6157 | spectrum | |
| 6158 | speculate | |
| 6159 | speech | |
| 6160 | speed | |
| 6161 | spellbind | |
| 6162 | speller | |
| 6163 | spelling | |
| 6164 | spendable | |
| 6165 | spender | |
| 6166 | spending | |
| 6167 | spent | |
| 6168 | spew | |
| 6169 | sphere | |
| 6170 | spherical | |
| 6171 | sphinx | |
| 6172 | spider | |
| 6173 | spied | |
| 6174 | spiffy | |
| 6175 | spill | |
| 6176 | spilt | |
| 6177 | spinach | |
| 6178 | spinal | |
| 6179 | spindle | |
| 6180 | spinner | |
| 6181 | spinning | |
| 6182 | spinout | |
| 6183 | spinster | |
| 6184 | spiny | |
| 6185 | spiral | |
| 6186 | spirited | |
| 6187 | spiritism | |
| 6188 | spirits | |
| 6189 | spiritual | |
| 6190 | splashed | |
| 6191 | splashing | |
| 6192 | splashy | |
| 6193 | splatter | |
| 6194 | spleen | |
| 6195 | splendid | |
| 6196 | splendor | |
| 6197 | splice | |
| 6198 | splicing | |
| 6199 | splinter | |
| 6200 | splotchy | |
| 6201 | splurge | |
| 6202 | spoilage | |
| 6203 | spoiled | |
| 6204 | spoiler | |
| 6205 | spoiling | |
| 6206 | spoils | |
| 6207 | spoken | |
| 6208 | spokesman | |
| 6209 | sponge | |
| 6210 | spongy | |
| 6211 | sponsor | |
| 6212 | spoof | |
| 6213 | spookily | |
| 6214 | spooky | |
| 6215 | spool | |
| 6216 | spoon | |
| 6217 | spore | |
| 6218 | sporting | |
| 6219 | sports | |
| 6220 | sporty | |
| 6221 | spotless | |
| 6222 | spotlight | |
| 6223 | spotted | |
| 6224 | spotter | |
| 6225 | spotting | |
| 6226 | spotty | |
| 6227 | spousal | |
| 6228 | spouse | |
| 6229 | spout | |
| 6230 | sprain | |
| 6231 | sprang | |
| 6232 | sprawl | |
| 6233 | spray | |
| 6234 | spree | |
| 6235 | sprig | |
| 6236 | spring | |
| 6237 | sprinkled | |
| 6238 | sprinkler | |
| 6239 | sprint | |
| 6240 | sprite | |
| 6241 | sprout | |
| 6242 | spruce | |
| 6243 | sprung | |
| 6244 | spry | |
| 6245 | spud | |
| 6246 | spur | |
| 6247 | sputter | |
| 6248 | spyglass | |
| 6249 | squabble | |
| 6250 | squad | |
| 6251 | squall | |
| 6252 | squander | |
| 6253 | squash | |
| 6254 | squatted | |
| 6255 | squatter | |
| 6256 | squatting | |
| 6257 | squeak | |
| 6258 | squealer | |
| 6259 | squealing | |
| 6260 | squeamish | |
| 6261 | squeegee | |
| 6262 | squeeze | |
| 6263 | squeezing | |
| 6264 | squid | |
| 6265 | squiggle | |
| 6266 | squiggly | |
| 6267 | squint | |
| 6268 | squire | |
| 6269 | squirt | |
| 6270 | squishier | |
| 6271 | squishy | |
| 6272 | stability | |
| 6273 | stabilize | |
| 6274 | stable | |
| 6275 | stack | |
| 6276 | stadium | |
| 6277 | staff | |
| 6278 | stage | |
| 6279 | staging | |
| 6280 | stagnant | |
| 6281 | stagnate | |
| 6282 | stainable | |
| 6283 | stained | |
| 6284 | staining | |
| 6285 | stainless | |
| 6286 | stalemate | |
| 6287 | staleness | |
| 6288 | stalling | |
| 6289 | stallion | |
| 6290 | stamina | |
| 6291 | stammer | |
| 6292 | stamp | |
| 6293 | stand | |
| 6294 | stank | |
| 6295 | staple | |
| 6296 | stapling | |
| 6297 | starboard | |
| 6298 | starch | |
| 6299 | stardom | |
| 6300 | stardust | |
| 6301 | starfish | |
| 6302 | stargazer | |
| 6303 | staring | |
| 6304 | stark | |
| 6305 | starless | |
| 6306 | starlet | |
| 6307 | starlight | |
| 6308 | starlit | |
| 6309 | starring | |
| 6310 | starry | |
| 6311 | starship | |
| 6312 | starter | |
| 6313 | starting | |
| 6314 | startle | |
| 6315 | startling | |
| 6316 | startup | |
| 6317 | starved | |
| 6318 | starving | |
| 6319 | stash | |
| 6320 | state | |
| 6321 | static | |
| 6322 | statistic | |
| 6323 | statue | |
| 6324 | stature | |
| 6325 | status | |
| 6326 | statute | |
| 6327 | statutory | |
| 6328 | staunch | |
| 6329 | stays | |
| 6330 | steadfast | |
| 6331 | steadier | |
| 6332 | steadily | |
| 6333 | steadying | |
| 6334 | steam | |
| 6335 | steed | |
| 6336 | steep | |
| 6337 | steerable | |
| 6338 | steering | |
| 6339 | steersman | |
| 6340 | stegosaur | |
| 6341 | stellar | |
| 6342 | stem | |
| 6343 | stench | |
| 6344 | stencil | |
| 6345 | step | |
| 6346 | stereo | |
| 6347 | sterile | |
| 6348 | sterility | |
| 6349 | sterilize | |
| 6350 | sterling | |
| 6351 | sternness | |
| 6352 | sternum | |
| 6353 | stew | |
| 6354 | stick | |
| 6355 | stiffen | |
| 6356 | stiffly | |
| 6357 | stiffness | |
| 6358 | stifle | |
| 6359 | stifling | |
| 6360 | stillness | |
| 6361 | stilt | |
| 6362 | stimulant | |
| 6363 | stimulate | |
| 6364 | stimuli | |
| 6365 | stimulus | |
| 6366 | stinger | |
| 6367 | stingily | |
| 6368 | stinging | |
| 6369 | stingray | |
| 6370 | stingy | |
| 6371 | stinking | |
| 6372 | stinky | |
| 6373 | stipend | |
| 6374 | stipulate | |
| 6375 | stir | |
| 6376 | stitch | |
| 6377 | stock | |
| 6378 | stoic | |
| 6379 | stoke | |
| 6380 | stole | |
| 6381 | stomp | |
| 6382 | stonewall | |
| 6383 | stoneware | |
| 6384 | stonework | |
| 6385 | stoning | |
| 6386 | stony | |
| 6387 | stood | |
| 6388 | stooge | |
| 6389 | stool | |
| 6390 | stoop | |
| 6391 | stoplight | |
| 6392 | stoppable | |
| 6393 | stoppage | |
| 6394 | stopped | |
| 6395 | stopper | |
| 6396 | stopping | |
| 6397 | stopwatch | |
| 6398 | storable | |
| 6399 | storage | |
| 6400 | storeroom | |
| 6401 | storewide | |
| 6402 | storm | |
| 6403 | stout | |
| 6404 | stove | |
| 6405 | stowaway | |
| 6406 | stowing | |
| 6407 | straddle | |
| 6408 | straggler | |
| 6409 | strained | |
| 6410 | strainer | |
| 6411 | straining | |
| 6412 | strangely | |
| 6413 | stranger | |
| 6414 | strangle | |
| 6415 | strategic | |
| 6416 | strategy | |
| 6417 | stratus | |
| 6418 | straw | |
| 6419 | stray | |
| 6420 | streak | |
| 6421 | stream | |
| 6422 | street | |
| 6423 | strength | |
| 6424 | strenuous | |
| 6425 | strep | |
| 6426 | stress | |
| 6427 | stretch | |
| 6428 | strewn | |
| 6429 | stricken | |
| 6430 | strict | |
| 6431 | stride | |
| 6432 | strife | |
| 6433 | strike | |
| 6434 | striking | |
| 6435 | strive | |
| 6436 | striving | |
| 6437 | strobe | |
| 6438 | strode | |
| 6439 | stroller | |
| 6440 | strongbox | |
| 6441 | strongly | |
| 6442 | strongman | |
| 6443 | struck | |
| 6444 | structure | |
| 6445 | strudel | |
| 6446 | struggle | |
| 6447 | strum | |
| 6448 | strung | |
| 6449 | strut | |
| 6450 | stubbed | |
| 6451 | stubble | |
| 6452 | stubbly | |
| 6453 | stubborn | |
| 6454 | stucco | |
| 6455 | stuck | |
| 6456 | student | |
| 6457 | studied | |
| 6458 | studio | |
| 6459 | study | |
| 6460 | stuffed | |
| 6461 | stuffing | |
| 6462 | stuffy | |
| 6463 | stumble | |
| 6464 | stumbling | |
| 6465 | stump | |
| 6466 | stung | |
| 6467 | stunned | |
| 6468 | stunner | |
| 6469 | stunning | |
| 6470 | stunt | |
| 6471 | stupor | |
| 6472 | sturdily | |
| 6473 | sturdy | |
| 6474 | styling | |
| 6475 | stylishly | |
| 6476 | stylist | |
| 6477 | stylized | |
| 6478 | stylus | |
| 6479 | suave | |
| 6480 | subarctic | |
| 6481 | subatomic | |
| 6482 | subdivide | |
| 6483 | subdued | |
| 6484 | subduing | |
| 6485 | subfloor | |
| 6486 | subgroup | |
| 6487 | subheader | |
| 6488 | subject | |
| 6489 | sublease | |
| 6490 | sublet | |
| 6491 | sublevel | |
| 6492 | sublime | |
| 6493 | submarine | |
| 6494 | submerge | |
| 6495 | submersed | |
| 6496 | submitter | |
| 6497 | subpanel | |
| 6498 | subpar | |
| 6499 | subplot | |
| 6500 | subprime | |
| 6501 | subscribe | |
| 6502 | subscript | |
| 6503 | subsector | |
| 6504 | subside | |
| 6505 | subsiding | |
| 6506 | subsidize | |
| 6507 | subsidy | |
| 6508 | subsoil | |
| 6509 | subsonic | |
| 6510 | substance | |
| 6511 | subsystem | |
| 6512 | subtext | |
| 6513 | subtitle | |
| 6514 | subtly | |
| 6515 | subtotal | |
| 6516 | subtract | |
| 6517 | subtype | |
| 6518 | suburb | |
| 6519 | subway | |
| 6520 | subwoofer | |
| 6521 | subzero | |
| 6522 | succulent | |
| 6523 | such | |
| 6524 | suction | |
| 6525 | sudden | |
| 6526 | sudoku | |
| 6527 | suds | |
| 6528 | sufferer | |
| 6529 | suffering | |
| 6530 | suffice | |
| 6531 | suffix | |
| 6532 | suffocate | |
| 6533 | suffrage | |
| 6534 | sugar | |
| 6535 | suggest | |
| 6536 | suing | |
| 6537 | suitable | |
| 6538 | suitably | |
| 6539 | suitcase | |
| 6540 | suitor | |
| 6541 | sulfate | |
| 6542 | sulfide | |
| 6543 | sulfite | |
| 6544 | sulfur | |
| 6545 | sulk | |
| 6546 | sullen | |
| 6547 | sulphate | |
| 6548 | sulphuric | |
| 6549 | sultry | |
| 6550 | superbowl | |
| 6551 | superglue | |
| 6552 | superhero | |
| 6553 | superior | |
| 6554 | superjet | |
| 6555 | superman | |
| 6556 | supermom | |
| 6557 | supernova | |
| 6558 | supervise | |
| 6559 | supper | |
| 6560 | supplier | |
| 6561 | supply | |
| 6562 | support | |
| 6563 | supremacy | |
| 6564 | supreme | |
| 6565 | surcharge | |
| 6566 | surely | |
| 6567 | sureness | |
| 6568 | surface | |
| 6569 | surfacing | |
| 6570 | surfboard | |
| 6571 | surfer | |
| 6572 | surgery | |
| 6573 | surgical | |
| 6574 | surging | |
| 6575 | surname | |
| 6576 | surpass | |
| 6577 | surplus | |
| 6578 | surprise | |
| 6579 | surreal | |
| 6580 | surrender | |
| 6581 | surrogate | |
| 6582 | surround | |
| 6583 | survey | |
| 6584 | survival | |
| 6585 | survive | |
| 6586 | surviving | |
| 6587 | survivor | |
| 6588 | sushi | |
| 6589 | suspect | |
| 6590 | suspend | |
| 6591 | suspense | |
| 6592 | sustained | |
| 6593 | sustainer | |
| 6594 | swab | |
| 6595 | swaddling | |
| 6596 | swagger | |
| 6597 | swampland | |
| 6598 | swan | |
| 6599 | swapping | |
| 6600 | swarm | |
| 6601 | sway | |
| 6602 | swear | |
| 6603 | sweat | |
| 6604 | sweep | |
| 6605 | swell | |
| 6606 | swept | |
| 6607 | swerve | |
| 6608 | swifter | |
| 6609 | swiftly | |
| 6610 | swiftness | |
| 6611 | swimmable | |
| 6612 | swimmer | |
| 6613 | swimming | |
| 6614 | swimsuit | |
| 6615 | swimwear | |
| 6616 | swinger | |
| 6617 | swinging | |
| 6618 | swipe | |
| 6619 | swirl | |
| 6620 | switch | |
| 6621 | swivel | |
| 6622 | swizzle | |
| 6623 | swooned | |
| 6624 | swoop | |
| 6625 | swoosh | |
| 6626 | swore | |
| 6627 | sworn | |
| 6628 | swung | |
| 6629 | sycamore | |
| 6630 | sympathy | |
| 6631 | symphonic | |
| 6632 | symphony | |
| 6633 | symptom | |
| 6634 | synapse | |
| 6635 | syndrome | |
| 6636 | synergy | |
| 6637 | synopses | |
| 6638 | synopsis | |
| 6639 | synthesis | |
| 6640 | synthetic | |
| 6641 | syrup | |
| 6642 | system | |
| 6643 | t-shirt | |
| 6644 | tabasco | |
| 6645 | tabby | |
| 6646 | tableful | |
| 6647 | tables | |
| 6648 | tablet | |
| 6649 | tableware | |
| 6650 | tabloid | |
| 6651 | tackiness | |
| 6652 | tacking | |
| 6653 | tackle | |
| 6654 | tackling | |
| 6655 | tacky | |
| 6656 | taco | |
| 6657 | tactful | |
| 6658 | tactical | |
| 6659 | tactics | |
| 6660 | tactile | |
| 6661 | tactless | |
| 6662 | tadpole | |
| 6663 | taekwondo | |
| 6664 | tag | |
| 6665 | tainted | |
| 6666 | take | |
| 6667 | taking | |
| 6668 | talcum | |
| 6669 | talisman | |
| 6670 | tall | |
| 6671 | talon | |
| 6672 | tamale | |
| 6673 | tameness | |
| 6674 | tamer | |
| 6675 | tamper | |
| 6676 | tank | |
| 6677 | tanned | |
| 6678 | tannery | |
| 6679 | tanning | |
| 6680 | tantrum | |
| 6681 | tapeless | |
| 6682 | tapered | |
| 6683 | tapering | |
| 6684 | tapestry | |
| 6685 | tapioca | |
| 6686 | tapping | |
| 6687 | taps | |
| 6688 | tarantula | |
| 6689 | target | |
| 6690 | tarmac | |
| 6691 | tarnish | |
| 6692 | tarot | |
| 6693 | tartar | |
| 6694 | tartly | |
| 6695 | tartness | |
| 6696 | task | |
| 6697 | tassel | |
| 6698 | taste | |
| 6699 | tastiness | |
| 6700 | tasting | |
| 6701 | tasty | |
| 6702 | tattered | |
| 6703 | tattle | |
| 6704 | tattling | |
| 6705 | tattoo | |
| 6706 | taunt | |
| 6707 | tavern | |
| 6708 | thank | |
| 6709 | that | |
| 6710 | thaw | |
| 6711 | theater | |
| 6712 | theatrics | |
| 6713 | thee | |
| 6714 | theft | |
| 6715 | theme | |
| 6716 | theology | |
| 6717 | theorize | |
| 6718 | thermal | |
| 6719 | thermos | |
| 6720 | thesaurus | |
| 6721 | these | |
| 6722 | thesis | |
| 6723 | thespian | |
| 6724 | thicken | |
| 6725 | thicket | |
| 6726 | thickness | |
| 6727 | thieving | |
| 6728 | thievish | |
| 6729 | thigh | |
| 6730 | thimble | |
| 6731 | thing | |
| 6732 | think | |
| 6733 | thinly | |
| 6734 | thinner | |
| 6735 | thinness | |
| 6736 | thinning | |
| 6737 | thirstily | |
| 6738 | thirsting | |
| 6739 | thirsty | |
| 6740 | thirteen | |
| 6741 | thirty | |
| 6742 | thong | |
| 6743 | thorn | |
| 6744 | those | |
| 6745 | thousand | |
| 6746 | thrash | |
| 6747 | thread | |
| 6748 | threaten | |
| 6749 | threefold | |
| 6750 | thrift | |
| 6751 | thrill | |
| 6752 | thrive | |
| 6753 | thriving | |
| 6754 | throat | |
| 6755 | throbbing | |
| 6756 | throng | |
| 6757 | throttle | |
| 6758 | throwaway | |
| 6759 | throwback | |
| 6760 | thrower | |
| 6761 | throwing | |
| 6762 | thud | |
| 6763 | thumb | |
| 6764 | thumping | |
| 6765 | thursday | |
| 6766 | thus | |
| 6767 | thwarting | |
| 6768 | thyself | |
| 6769 | tiara | |
| 6770 | tibia | |
| 6771 | tidal | |
| 6772 | tidbit | |
| 6773 | tidiness | |
| 6774 | tidings | |
| 6775 | tidy | |
| 6776 | tiger | |
| 6777 | tighten | |
| 6778 | tightly | |
| 6779 | tightness | |
| 6780 | tightrope | |
| 6781 | tightwad | |
| 6782 | tigress | |
| 6783 | tile | |
| 6784 | tiling | |
| 6785 | till | |
| 6786 | tilt | |
| 6787 | timid | |
| 6788 | timing | |
| 6789 | timothy | |
| 6790 | tinderbox | |
| 6791 | tinfoil | |
| 6792 | tingle | |
| 6793 | tingling | |
| 6794 | tingly | |
| 6795 | tinker | |
| 6796 | tinkling | |
| 6797 | tinsel | |
| 6798 | tinsmith | |
| 6799 | tint | |
| 6800 | tinwork | |
| 6801 | tiny | |
| 6802 | tipoff | |
| 6803 | tipped | |
| 6804 | tipper | |
| 6805 | tipping | |
| 6806 | tiptoeing | |
| 6807 | tiptop | |
| 6808 | tiring | |
| 6809 | tissue | |
| 6810 | trace | |
| 6811 | tracing | |
| 6812 | track | |
| 6813 | traction | |
| 6814 | tractor | |
| 6815 | trade | |
| 6816 | trading | |
| 6817 | tradition | |
| 6818 | traffic | |
| 6819 | tragedy | |
| 6820 | trailing | |
| 6821 | trailside | |
| 6822 | train | |
| 6823 | traitor | |
| 6824 | trance | |
| 6825 | tranquil | |
| 6826 | transfer | |
| 6827 | transform | |
| 6828 | translate | |
| 6829 | transpire | |
| 6830 | transport | |
| 6831 | transpose | |
| 6832 | trapdoor | |
| 6833 | trapeze | |
| 6834 | trapezoid | |
| 6835 | trapped | |
| 6836 | trapper | |
| 6837 | trapping | |
| 6838 | traps | |
| 6839 | trash | |
| 6840 | travel | |
| 6841 | traverse | |
| 6842 | travesty | |
| 6843 | tray | |
| 6844 | treachery | |
| 6845 | treading | |
| 6846 | treadmill | |
| 6847 | treason | |
| 6848 | treat | |
| 6849 | treble | |
| 6850 | tree | |
| 6851 | trekker | |
| 6852 | tremble | |
| 6853 | trembling | |
| 6854 | tremor | |
| 6855 | trench | |
| 6856 | trend | |
| 6857 | trespass | |
| 6858 | triage | |
| 6859 | trial | |
| 6860 | triangle | |
| 6861 | tribesman | |
| 6862 | tribunal | |
| 6863 | tribune | |
| 6864 | tributary | |
| 6865 | tribute | |
| 6866 | triceps | |
| 6867 | trickery | |
| 6868 | trickily | |
| 6869 | tricking | |
| 6870 | trickle | |
| 6871 | trickster | |
| 6872 | tricky | |
| 6873 | tricolor | |
| 6874 | tricycle | |
| 6875 | trident | |
| 6876 | tried | |
| 6877 | trifle | |
| 6878 | trifocals | |
| 6879 | trillion | |
| 6880 | trilogy | |
| 6881 | trimester | |
| 6882 | trimmer | |
| 6883 | trimming | |
| 6884 | trimness | |
| 6885 | trinity | |
| 6886 | trio | |
| 6887 | tripod | |
| 6888 | tripping | |
| 6889 | triumph | |
| 6890 | trivial | |
| 6891 | trodden | |
| 6892 | trolling | |
| 6893 | trombone | |
| 6894 | trophy | |
| 6895 | tropical | |
| 6896 | tropics | |
| 6897 | trouble | |
| 6898 | troubling | |
| 6899 | trough | |
| 6900 | trousers | |
| 6901 | trout | |
| 6902 | trowel | |
| 6903 | truce | |
| 6904 | truck | |
| 6905 | truffle | |
| 6906 | trump | |
| 6907 | trunks | |
| 6908 | trustable | |
| 6909 | trustee | |
| 6910 | trustful | |
| 6911 | trusting | |
| 6912 | trustless | |
| 6913 | truth | |
| 6914 | try | |
| 6915 | tubby | |
| 6916 | tubeless | |
| 6917 | tubular | |
| 6918 | tucking | |
| 6919 | tuesday | |
| 6920 | tug | |
| 6921 | tuition | |
| 6922 | tulip | |
| 6923 | tumble | |
| 6924 | tumbling | |
| 6925 | tummy | |
| 6926 | turban | |
| 6927 | turbine | |
| 6928 | turbofan | |
| 6929 | turbojet | |
| 6930 | turbulent | |
| 6931 | turf | |
| 6932 | turkey | |
| 6933 | turmoil | |
| 6934 | turret | |
| 6935 | turtle | |
| 6936 | tusk | |
| 6937 | tutor | |
| 6938 | tutu | |
| 6939 | tux | |
| 6940 | tweak | |
| 6941 | tweed | |
| 6942 | tweet | |
| 6943 | tweezers | |
| 6944 | twelve | |
| 6945 | twentieth | |
| 6946 | twenty | |
| 6947 | twerp | |
| 6948 | twice | |
| 6949 | twiddle | |
| 6950 | twiddling | |
| 6951 | twig | |
| 6952 | twilight | |
| 6953 | twine | |
| 6954 | twins | |
| 6955 | twirl | |
| 6956 | twistable | |
| 6957 | twisted | |
| 6958 | twister | |
| 6959 | twisting | |
| 6960 | twisty | |
| 6961 | twitch | |
| 6962 | ||
| 6963 | tycoon | |
| 6964 | tying | |
| 6965 | tyke | |
| 6966 | udder | |
| 6967 | ultimate | |
| 6968 | ultimatum | |
| 6969 | ultra | |
| 6970 | umbilical | |
| 6971 | umbrella | |
| 6972 | umpire | |
| 6973 | unabashed | |
| 6974 | unable | |
| 6975 | unadorned | |
| 6976 | unadvised | |
| 6977 | unafraid | |
| 6978 | unaired | |
| 6979 | unaligned | |
| 6980 | unaltered | |
| 6981 | unarmored | |
| 6982 | unashamed | |
| 6983 | unaudited | |
| 6984 | unawake | |
| 6985 | unaware | |
| 6986 | unbaked | |
| 6987 | unbalance | |
| 6988 | unbeaten | |
| 6989 | unbend | |
| 6990 | unbent | |
| 6991 | unbiased | |
| 6992 | unbitten | |
| 6993 | unblended | |
| 6994 | unblessed | |
| 6995 | unblock | |
| 6996 | unbolted | |
| 6997 | unbounded | |
| 6998 | unboxed | |
| 6999 | unbraided | |
| 7000 | unbridle | |
| 7001 | unbroken | |
| 7002 | unbuckled | |
| 7003 | unbundle | |
| 7004 | unburned | |
| 7005 | unbutton | |
| 7006 | uncanny | |
| 7007 | uncapped | |
| 7008 | uncaring | |
| 7009 | uncertain | |
| 7010 | unchain | |
| 7011 | unchanged | |
| 7012 | uncharted | |
| 7013 | uncheck | |
| 7014 | uncivil | |
| 7015 | unclad | |
| 7016 | unclaimed | |
| 7017 | unclamped | |
| 7018 | unclasp | |
| 7019 | uncle | |
| 7020 | unclip | |
| 7021 | uncloak | |
| 7022 | unclog | |
| 7023 | unclothed | |
| 7024 | uncoated | |
| 7025 | uncoiled | |
| 7026 | uncolored | |
| 7027 | uncombed | |
| 7028 | uncommon | |
| 7029 | uncooked | |
| 7030 | uncork | |
| 7031 | uncorrupt | |
| 7032 | uncounted | |
| 7033 | uncouple | |
| 7034 | uncouth | |
| 7035 | uncover | |
| 7036 | uncross | |
| 7037 | uncrown | |
| 7038 | uncrushed | |
| 7039 | uncured | |
| 7040 | uncurious | |
| 7041 | uncurled | |
| 7042 | uncut | |
| 7043 | undamaged | |
| 7044 | undated | |
| 7045 | undaunted | |
| 7046 | undead | |
| 7047 | undecided | |
| 7048 | undefined | |
| 7049 | underage | |
| 7050 | underarm | |
| 7051 | undercoat | |
| 7052 | undercook | |
| 7053 | undercut | |
| 7054 | underdog | |
| 7055 | underdone | |
| 7056 | underfed | |
| 7057 | underfeed | |
| 7058 | underfoot | |
| 7059 | undergo | |
| 7060 | undergrad | |
| 7061 | underhand | |
| 7062 | underline | |
| 7063 | underling | |
| 7064 | undermine | |
| 7065 | undermost | |
| 7066 | underpaid | |
| 7067 | underpass | |
| 7068 | underpay | |
| 7069 | underrate | |
| 7070 | undertake | |
| 7071 | undertone | |
| 7072 | undertook | |
| 7073 | undertow | |
| 7074 | underuse | |
| 7075 | underwear | |
| 7076 | underwent | |
| 7077 | underwire | |
| 7078 | undesired | |
| 7079 | undiluted | |
| 7080 | undivided | |
| 7081 | undocked | |
| 7082 | undoing | |
| 7083 | undone | |
| 7084 | undrafted | |
| 7085 | undress | |
| 7086 | undrilled | |
| 7087 | undusted | |
| 7088 | undying | |
| 7089 | unearned | |
| 7090 | unearth | |
| 7091 | unease | |
| 7092 | uneasily | |
| 7093 | uneasy | |
| 7094 | uneatable | |
| 7095 | uneaten | |
| 7096 | unedited | |
| 7097 | unelected | |
| 7098 | unending | |
| 7099 | unengaged | |
| 7100 | unenvied | |
| 7101 | unequal | |
| 7102 | unethical | |
| 7103 | uneven | |
| 7104 | unexpired | |
| 7105 | unexposed | |
| 7106 | unfailing | |
| 7107 | unfair | |
| 7108 | unfasten | |
| 7109 | unfazed | |
| 7110 | unfeeling | |
| 7111 | unfiled | |
| 7112 | unfilled | |
| 7113 | unfitted | |
| 7114 | unfitting | |
| 7115 | unfixable | |
| 7116 | unfixed | |
| 7117 | unflawed | |
| 7118 | unfocused | |
| 7119 | unfold | |
| 7120 | unfounded | |
| 7121 | unframed | |
| 7122 | unfreeze | |
| 7123 | unfrosted | |
| 7124 | unfrozen | |
| 7125 | unfunded | |
| 7126 | unglazed | |
| 7127 | ungloved | |
| 7128 | unglue | |
| 7129 | ungodly | |
| 7130 | ungraded | |
| 7131 | ungreased | |
| 7132 | unguarded | |
| 7133 | unguided | |
| 7134 | unhappily | |
| 7135 | unhappy | |
| 7136 | unharmed | |
| 7137 | unhealthy | |
| 7138 | unheard | |
| 7139 | unhearing | |
| 7140 | unheated | |
| 7141 | unhelpful | |
| 7142 | unhidden | |
| 7143 | unhinge | |
| 7144 | unhitched | |
| 7145 | unholy | |
| 7146 | unhook | |
| 7147 | unicorn | |
| 7148 | unicycle | |
| 7149 | unified | |
| 7150 | unifier | |
| 7151 | uniformed | |
| 7152 | uniformly | |
| 7153 | unify | |
| 7154 | unimpeded | |
| 7155 | uninjured | |
| 7156 | uninstall | |
| 7157 | uninsured | |
| 7158 | uninvited | |
| 7159 | union | |
| 7160 | uniquely | |
| 7161 | unisexual | |
| 7162 | unison | |
| 7163 | unissued | |
| 7164 | unit | |
| 7165 | universal | |
| 7166 | universe | |
| 7167 | unjustly | |
| 7168 | unkempt | |
| 7169 | unkind | |
| 7170 | unknotted | |
| 7171 | unknowing | |
| 7172 | unknown | |
| 7173 | unlaced | |
| 7174 | unlatch | |
| 7175 | unlawful | |
| 7176 | unleaded | |
| 7177 | unlearned | |
| 7178 | unleash | |
| 7179 | unless | |
| 7180 | unleveled | |
| 7181 | unlighted | |
| 7182 | unlikable | |
| 7183 | unlimited | |
| 7184 | unlined | |
| 7185 | unlinked | |
| 7186 | unlisted | |
| 7187 | unlit | |
| 7188 | unlivable | |
| 7189 | unloaded | |
| 7190 | unloader | |
| 7191 | unlocked | |
| 7192 | unlocking | |
| 7193 | unlovable | |
| 7194 | unloved | |
| 7195 | unlovely | |
| 7196 | unloving | |
| 7197 | unluckily | |
| 7198 | unlucky | |
| 7199 | unmade | |
| 7200 | unmanaged | |
| 7201 | unmanned | |
| 7202 | unmapped | |
| 7203 | unmarked | |
| 7204 | unmasked | |
| 7205 | unmasking | |
| 7206 | unmatched | |
| 7207 | unmindful | |
| 7208 | unmixable | |
| 7209 | unmixed | |
| 7210 | unmolded | |
| 7211 | unmoral | |
| 7212 | unmovable | |
| 7213 | unmoved | |
| 7214 | unmoving | |
| 7215 | unnamable | |
| 7216 | unnamed | |
| 7217 | unnatural | |
| 7218 | unneeded | |
| 7219 | unnerve | |
| 7220 | unnerving | |
| 7221 | unnoticed | |
| 7222 | unopened | |
| 7223 | unopposed | |
| 7224 | unpack | |
| 7225 | unpadded | |
| 7226 | unpaid | |
| 7227 | unpainted | |
| 7228 | unpaired | |
| 7229 | unpaved | |
| 7230 | unpeeled | |
| 7231 | unpicked | |
| 7232 | unpiloted | |
| 7233 | unpinned | |
| 7234 | unplanned | |
| 7235 | unplanted | |
| 7236 | unpleased | |
| 7237 | unpledged | |
| 7238 | unplowed | |
| 7239 | unplug | |
| 7240 | unpopular | |
| 7241 | unproven | |
| 7242 | unquote | |
| 7243 | unranked | |
| 7244 | unrated | |
| 7245 | unraveled | |
| 7246 | unreached | |
| 7247 | unread | |
| 7248 | unreal | |
| 7249 | unreeling | |
| 7250 | unrefined | |
| 7251 | unrelated | |
| 7252 | unrented | |
| 7253 | unrest | |
| 7254 | unretired | |
| 7255 | unrevised | |
| 7256 | unrigged | |
| 7257 | unripe | |
| 7258 | unrivaled | |
| 7259 | unroasted | |
| 7260 | unrobed | |
| 7261 | unroll | |
| 7262 | unruffled | |
| 7263 | unruly | |
| 7264 | unrushed | |
| 7265 | unsaddle | |
| 7266 | unsafe | |
| 7267 | unsaid | |
| 7268 | unsalted | |
| 7269 | unsaved | |
| 7270 | unsavory | |
| 7271 | unscathed | |
| 7272 | unscented | |
| 7273 | unscrew | |
| 7274 | unsealed | |
| 7275 | unseated | |
| 7276 | unsecured | |
| 7277 | unseeing | |
| 7278 | unseemly | |
| 7279 | unseen | |
| 7280 | unselect | |
| 7281 | unselfish | |
| 7282 | unsent | |
| 7283 | unsettled | |
| 7284 | unshackle | |
| 7285 | unshaken | |
| 7286 | unshaved | |
| 7287 | unshaven | |
| 7288 | unsheathe | |
| 7289 | unshipped | |
| 7290 | unsightly | |
| 7291 | unsigned | |
| 7292 | unskilled | |
| 7293 | unsliced | |
| 7294 | unsmooth | |
| 7295 | unsnap | |
| 7296 | unsocial | |
| 7297 | unsoiled | |
| 7298 | unsold | |
| 7299 | unsolved | |
| 7300 | unsorted | |
| 7301 | unspoiled | |
| 7302 | unspoken | |
| 7303 | unstable | |
| 7304 | unstaffed | |
| 7305 | unstamped | |
| 7306 | unsteady | |
| 7307 | unsterile | |
| 7308 | unstirred | |
| 7309 | unstitch | |
| 7310 | unstopped | |
| 7311 | unstuck | |
| 7312 | unstuffed | |
| 7313 | unstylish | |
| 7314 | unsubtle | |
| 7315 | unsubtly | |
| 7316 | unsuited | |
| 7317 | unsure | |
| 7318 | unsworn | |
| 7319 | untagged | |
| 7320 | untainted | |
| 7321 | untaken | |
| 7322 | untamed | |
| 7323 | untangled | |
| 7324 | untapped | |
| 7325 | untaxed | |
| 7326 | unthawed | |
| 7327 | unthread | |
| 7328 | untidy | |
| 7329 | untie | |
| 7330 | until | |
| 7331 | untimed | |
| 7332 | untimely | |
| 7333 | untitled | |
| 7334 | untoasted | |
| 7335 | untold | |
| 7336 | untouched | |
| 7337 | untracked | |
| 7338 | untrained | |
| 7339 | untreated | |
| 7340 | untried | |
| 7341 | untrimmed | |
| 7342 | untrue | |
| 7343 | untruth | |
| 7344 | unturned | |
| 7345 | untwist | |
| 7346 | untying | |
| 7347 | unusable | |
| 7348 | unused | |
| 7349 | unusual | |
| 7350 | unvalued | |
| 7351 | unvaried | |
| 7352 | unvarying | |
| 7353 | unveiled | |
| 7354 | unveiling | |
| 7355 | unvented | |
| 7356 | unviable | |
| 7357 | unvisited | |
| 7358 | unvocal | |
| 7359 | unwanted | |
| 7360 | unwarlike | |
| 7361 | unwary | |
| 7362 | unwashed | |
| 7363 | unwatched | |
| 7364 | unweave | |
| 7365 | unwed | |
| 7366 | unwelcome | |
| 7367 | unwell | |
| 7368 | unwieldy | |
| 7369 | unwilling | |
| 7370 | unwind | |
| 7371 | unwired | |
| 7372 | unwitting | |
| 7373 | unwomanly | |
| 7374 | unworldly | |
| 7375 | unworn | |
| 7376 | unworried | |
| 7377 | unworthy | |
| 7378 | unwound | |
| 7379 | unwoven | |
| 7380 | unwrapped | |
| 7381 | unwritten | |
| 7382 | unzip | |
| 7383 | upbeat | |
| 7384 | upchuck | |
| 7385 | upcoming | |
| 7386 | upcountry | |
| 7387 | update | |
| 7388 | upfront | |
| 7389 | upgrade | |
| 7390 | upheaval | |
| 7391 | upheld | |
| 7392 | uphill | |
| 7393 | uphold | |
| 7394 | uplifted | |
| 7395 | uplifting | |
| 7396 | upload | |
| 7397 | upon | |
| 7398 | upper | |
| 7399 | upright | |
| 7400 | uprising | |
| 7401 | upriver | |
| 7402 | uproar | |
| 7403 | uproot | |
| 7404 | upscale | |
| 7405 | upside | |
| 7406 | upstage | |
| 7407 | upstairs | |
| 7408 | upstart | |
| 7409 | upstate | |
| 7410 | upstream | |
| 7411 | upstroke | |
| 7412 | upswing | |
| 7413 | uptake | |
| 7414 | uptight | |
| 7415 | uptown | |
| 7416 | upturned | |
| 7417 | upward | |
| 7418 | upwind | |
| 7419 | uranium | |
| 7420 | urban | |
| 7421 | urchin | |
| 7422 | urethane | |
| 7423 | urgency | |
| 7424 | urgent | |
| 7425 | urging | |
| 7426 | urologist | |
| 7427 | urology | |
| 7428 | usable | |
| 7429 | usage | |
| 7430 | useable | |
| 7431 | used | |
| 7432 | uselessly | |
| 7433 | user | |
| 7434 | usher | |
| 7435 | usual | |
| 7436 | utensil | |
| 7437 | utility | |
| 7438 | utilize | |
| 7439 | utmost | |
| 7440 | utopia | |
| 7441 | utter | |
| 7442 | vacancy | |
| 7443 | vacant | |
| 7444 | vacate | |
| 7445 | vacation | |
| 7446 | vagabond | |
| 7447 | vagrancy | |
| 7448 | vagrantly | |
| 7449 | vaguely | |
| 7450 | vagueness | |
| 7451 | valiant | |
| 7452 | valid | |
| 7453 | valium | |
| 7454 | valley | |
| 7455 | valuables | |
| 7456 | value | |
| 7457 | vanilla | |
| 7458 | vanish | |
| 7459 | vanity | |
| 7460 | vanquish | |
| 7461 | vantage | |
| 7462 | vaporizer | |
| 7463 | variable | |
| 7464 | variably | |
| 7465 | varied | |
| 7466 | variety | |
| 7467 | various | |
| 7468 | varmint | |
| 7469 | varnish | |
| 7470 | varsity | |
| 7471 | varying | |
| 7472 | vascular | |
| 7473 | vaseline | |
| 7474 | vastly | |
| 7475 | vastness | |
| 7476 | veal | |
| 7477 | vegan | |
| 7478 | veggie | |
| 7479 | vehicular | |
| 7480 | velcro | |
| 7481 | velocity | |
| 7482 | velvet | |
| 7483 | vendetta | |
| 7484 | vending | |
| 7485 | vendor | |
| 7486 | veneering | |
| 7487 | vengeful | |
| 7488 | venomous | |
| 7489 | ventricle | |
| 7490 | venture | |
| 7491 | venue | |
| 7492 | venus | |
| 7493 | verbalize | |
| 7494 | verbally | |
| 7495 | verbose | |
| 7496 | verdict | |
| 7497 | verify | |
| 7498 | verse | |
| 7499 | version | |
| 7500 | versus | |
| 7501 | vertebrae | |
| 7502 | vertical | |
| 7503 | vertigo | |
| 7504 | very | |
| 7505 | vessel | |
| 7506 | vest | |
| 7507 | veteran | |
| 7508 | veto | |
| 7509 | vexingly | |
| 7510 | viability | |
| 7511 | viable | |
| 7512 | vibes | |
| 7513 | vice | |
| 7514 | vicinity | |
| 7515 | victory | |
| 7516 | video | |
| 7517 | viewable | |
| 7518 | viewer | |
| 7519 | viewing | |
| 7520 | viewless | |
| 7521 | viewpoint | |
| 7522 | vigorous | |
| 7523 | village | |
| 7524 | villain | |
| 7525 | vindicate | |
| 7526 | vineyard | |
| 7527 | vintage | |
| 7528 | violate | |
| 7529 | violation | |
| 7530 | violator | |
| 7531 | violet | |
| 7532 | violin | |
| 7533 | viper | |
| 7534 | viral | |
| 7535 | virtual | |
| 7536 | virtuous | |
| 7537 | virus | |
| 7538 | visa | |
| 7539 | viscosity | |
| 7540 | viscous | |
| 7541 | viselike | |
| 7542 | visible | |
| 7543 | visibly | |
| 7544 | vision | |
| 7545 | visiting | |
| 7546 | visitor | |
| 7547 | visor | |
| 7548 | vista | |
| 7549 | vitality | |
| 7550 | vitalize | |
| 7551 | vitally | |
| 7552 | vitamins | |
| 7553 | vivacious | |
| 7554 | vividly | |
| 7555 | vividness | |
| 7556 | vixen | |
| 7557 | vocalist | |
| 7558 | vocalize | |
| 7559 | vocally | |
| 7560 | vocation | |
| 7561 | voice | |
| 7562 | voicing | |
| 7563 | void | |
| 7564 | volatile | |
| 7565 | volley | |
| 7566 | voltage | |
| 7567 | volumes | |
| 7568 | voter | |
| 7569 | voting | |
| 7570 | voucher | |
| 7571 | vowed | |
| 7572 | vowel | |
| 7573 | voyage | |
| 7574 | wackiness | |
| 7575 | wad | |
| 7576 | wafer | |
| 7577 | waffle | |
| 7578 | waged | |
| 7579 | wager | |
| 7580 | wages | |
| 7581 | waggle | |
| 7582 | wagon | |
| 7583 | wake | |
| 7584 | waking | |
| 7585 | walk | |
| 7586 | walmart | |
| 7587 | walnut | |
| 7588 | walrus | |
| 7589 | waltz | |
| 7590 | wand | |
| 7591 | wannabe | |
| 7592 | wanted | |
| 7593 | wanting | |
| 7594 | wasabi | |
| 7595 | washable | |
| 7596 | washbasin | |
| 7597 | washboard | |
| 7598 | washbowl | |
| 7599 | washcloth | |
| 7600 | washday | |
| 7601 | washed | |
| 7602 | washer | |
| 7603 | washhouse | |
| 7604 | washing | |
| 7605 | washout | |
| 7606 | washroom | |
| 7607 | washstand | |
| 7608 | washtub | |
| 7609 | wasp | |
| 7610 | wasting | |
| 7611 | watch | |
| 7612 | water | |
| 7613 | waviness | |
| 7614 | waving | |
| 7615 | wavy | |
| 7616 | whacking | |
| 7617 | whacky | |
| 7618 | wham | |
| 7619 | wharf | |
| 7620 | wheat | |
| 7621 | whenever | |
| 7622 | whiff | |
| 7623 | whimsical | |
| 7624 | whinny | |
| 7625 | whiny | |
| 7626 | whisking | |
| 7627 | whoever | |
| 7628 | whole | |
| 7629 | whomever | |
| 7630 | whoopee | |
| 7631 | whooping | |
| 7632 | whoops | |
| 7633 | why | |
| 7634 | wick | |
| 7635 | widely | |
| 7636 | widen | |
| 7637 | widget | |
| 7638 | widow | |
| 7639 | width | |
| 7640 | wieldable | |
| 7641 | wielder | |
| 7642 | wife | |
| 7643 | wifi | |
| 7644 | wikipedia | |
| 7645 | wildcard | |
| 7646 | wildcat | |
| 7647 | wilder | |
| 7648 | wildfire | |
| 7649 | wildfowl | |
| 7650 | wildland | |
| 7651 | wildlife | |
| 7652 | wildly | |
| 7653 | wildness | |
| 7654 | willed | |
| 7655 | willfully | |
| 7656 | willing | |
| 7657 | willow | |
| 7658 | willpower | |
| 7659 | wilt | |
| 7660 | wimp | |
| 7661 | wince | |
| 7662 | wincing | |
| 7663 | wind | |
| 7664 | wing | |
| 7665 | winking | |
| 7666 | winner | |
| 7667 | winnings | |
| 7668 | winter | |
| 7669 | wipe | |
| 7670 | wired | |
| 7671 | wireless | |
| 7672 | wiring | |
| 7673 | wiry | |
| 7674 | wisdom | |
| 7675 | wise | |
| 7676 | wish | |
| 7677 | wisplike | |
| 7678 | wispy | |
| 7679 | wistful | |
| 7680 | wizard | |
| 7681 | wobble | |
| 7682 | wobbling | |
| 7683 | wobbly | |
| 7684 | wok | |
| 7685 | wolf | |
| 7686 | wolverine | |
| 7687 | womanhood | |
| 7688 | womankind | |
| 7689 | womanless | |
| 7690 | womanlike | |
| 7691 | womanly | |
| 7692 | womb | |
| 7693 | woof | |
| 7694 | wooing | |
| 7695 | wool | |
| 7696 | woozy | |
| 7697 | word | |
| 7698 | work | |
| 7699 | worried | |
| 7700 | worrier | |
| 7701 | worrisome | |
| 7702 | worry | |
| 7703 | worsening | |
| 7704 | worshiper | |
| 7705 | worst | |
| 7706 | wound | |
| 7707 | woven | |
| 7708 | wow | |
| 7709 | wrangle | |
| 7710 | wrath | |
| 7711 | wreath | |
| 7712 | wreckage | |
| 7713 | wrecker | |
| 7714 | wrecking | |
| 7715 | wrench | |
| 7716 | wriggle | |
| 7717 | wriggly | |
| 7718 | wrinkle | |
| 7719 | wrinkly | |
| 7720 | wrist | |
| 7721 | writing | |
| 7722 | written | |
| 7723 | wrongdoer | |
| 7724 | wronged | |
| 7725 | wrongful | |
| 7726 | wrongly | |
| 7727 | wrongness | |
| 7728 | wrought | |
| 7729 | xbox | |
| 7730 | xerox | |
| 7731 | yahoo | |
| 7732 | yam | |
| 7733 | yanking | |
| 7734 | yapping | |
| 7735 | yard | |
| 7736 | yarn | |
| 7737 | yeah | |
| 7738 | yearbook | |
| 7739 | yearling | |
| 7740 | yearly | |
| 7741 | yearning | |
| 7742 | yeast | |
| 7743 | yelling | |
| 7744 | yelp | |
| 7745 | yen | |
| 7746 | yesterday | |
| 7747 | yiddish | |
| 7748 | yield | |
| 7749 | yin | |
| 7750 | yippee | |
| 7751 | yo-yo | |
| 7752 | yodel | |
| 7753 | yoga | |
| 7754 | yogurt | |
| 7755 | yonder | |
| 7756 | yoyo | |
| 7757 | yummy | |
| 7758 | zap | |
| 7759 | zealous | |
| 7760 | zebra | |
| 7761 | zen | |
| 7762 | zeppelin | |
| 7763 | zero | |
| 7764 | zestfully | |
| 7765 | zesty | |
| 7766 | zigzagged | |
| 7767 | zipfile | |
| 7768 | zipping | |
| 7769 | zippy | |
| 7770 | zips | |
| 7771 | zit | |
| 7772 | zodiac | |
| 7773 | zombie | |
| 7774 | zone | |
| 7775 | zoning | |
| 7776 | zookeeper | |
| 7777 | zoologist | |
| 7778 | zoology | |
| 7779 | zoom | |
| 7780 | """ | |
| 7781 | ||
| 7782 | public enum Wordlist { | |
| 7783 | public static let words: [String] = effLongWordlist.split(separator: "\n").map(String.init) | |
| 7784 | } | |
Sources/keycask/main.swift added +3
| @@ -0,0 +1,3 @@ | ||
| 1 | import KeycaskCore | |
| 2 | ||
| 3 | print("keycask") | |
Tests/KeycaskCLITests/CLI.swift added +32
| @@ -0,0 +1,32 @@ | ||
| 1 | import Foundation | |
| 2 | import Testing | |
| 3 | ||
| 4 | enum Binary { | |
| 5 | static let url: URL = { | |
| 6 | #if os(macOS) | |
| 7 | if let index = CommandLine.arguments.firstIndex(of: "--test-bundle-path"), | |
| 8 | CommandLine.arguments.count > index + 1 | |
| 9 | { | |
| 10 | return URL(fileURLWithPath: CommandLine.arguments[index + 1]) | |
| 11 | .deletingLastPathComponent() // MacOS | |
| 12 | .deletingLastPathComponent() // Contents | |
| 13 | .deletingLastPathComponent() // *.xctest | |
| 14 | .deletingLastPathComponent() // Products/Debug | |
| 15 | .appendingPathComponent("keycask") | |
| 16 | } | |
| 17 | for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { | |
| 18 | return bundle.bundleURL.deletingLastPathComponent().appendingPathComponent( | |
| 19 | "keycask") | |
| 20 | } | |
| 21 | fatalError("test bundle not found") | |
| 22 | #elseif os(Windows) | |
| 23 | return Bundle.main.bundleURL.appendingPathComponent("keycask.exe") | |
| 24 | #else | |
| 25 | return Bundle.main.bundleURL.appendingPathComponent("keycask") | |
| 26 | #endif | |
| 27 | }() | |
| 28 | } | |
| 29 | ||
| 30 | @Test func binaryIsBuilt() { | |
| 31 | #expect(FileManager.default.isExecutableFile(atPath: Binary.url.path)) | |
| 32 | } | |
Tests/KeycaskCoreTests/EntryIDTests.swift added +55
| @@ -0,0 +1,55 @@ | ||
| 1 | import Foundation | |
| 2 | import Testing | |
| 3 | ||
| 4 | @testable import KeycaskCore | |
| 5 | ||
| 6 | @Suite struct EntryIDTests { | |
| 7 | @Test func randomIDsHaveLengthEightFromTheAlphabet() { | |
| 8 | let allowed = Set(EntryID.alphabet) | |
| 9 | for _ in 0..<200 { | |
| 10 | let id = EntryID.random() | |
| 11 | #expect(id.rawValue.count == 8) | |
| 12 | #expect(id.rawValue.allSatisfy { allowed.contains($0) }) | |
| 13 | } | |
| 14 | } | |
| 15 | ||
| 16 | @Test func alphabetExcludesAmbiguousCharacters() { | |
| 17 | let alphabet = Set(EntryID.alphabet) | |
| 18 | #expect(alphabet.count == 32) | |
| 19 | for bad in ["l", "o", "0", "1"] { | |
| 20 | #expect(!alphabet.contains(Character(bad))) | |
| 21 | } | |
| 22 | } | |
| 23 | ||
| 24 | @Test func parsingValidatesLengthAndAlphabet() { | |
| 25 | #expect(EntryID("abcd2345") != nil) | |
| 26 | #expect(EntryID("abcd234") == nil) | |
| 27 | #expect(EntryID("abcd23456") == nil) | |
| 28 | #expect(EntryID("abcd234l") == nil) | |
| 29 | #expect(EntryID("ABCD2345") == nil) | |
| 30 | } | |
| 31 | ||
| 32 | @Test func codableIsABareString() throws { | |
| 33 | let id = EntryID("abcd2345")! | |
| 34 | let data = try JSONEncoder().encode([id]) | |
| 35 | #expect(String(decoding: data, as: UTF8.self) == "[\"abcd2345\"]") | |
| 36 | let back = try JSONDecoder().decode([EntryID].self, from: data) | |
| 37 | #expect(back == [id]) | |
| 38 | #expect(throws: DecodingError.self) { | |
| 39 | try JSONDecoder().decode([EntryID].self, from: Data("[\"bad\"]".utf8)) | |
| 40 | } | |
| 41 | } | |
| 42 | ||
| 43 | @Test func seededGeneratorIsDeterministic() { | |
| 44 | struct Counter: RandomNumberGenerator { | |
| 45 | var n: UInt64 = 0 | |
| 46 | mutating func next() -> UInt64 { | |
| 47 | n += 1 | |
| 48 | return n | |
| 49 | } | |
| 50 | } | |
| 51 | var a = Counter() | |
| 52 | var b = Counter() | |
| 53 | #expect(EntryID.random(using: &a) == EntryID.random(using: &b)) | |
| 54 | } | |
| 55 | } | |
Tests/KeycaskCoreTests/EntryTests.swift added +40
| @@ -0,0 +1,40 @@ | ||
| 1 | import Foundation | |
| 2 | import Testing | |
| 3 | ||
| 4 | @testable import KeycaskCore | |
| 5 | ||
| 6 | @Suite struct EntryTests { | |
| 7 | @Test func initNormalizesTagsAndTruncatesDates() { | |
| 8 | let now = Date(timeIntervalSince1970: 1_700_000_000.75) | |
| 9 | let e = Entry( | |
| 10 | name: "gh", password: "p", tags: [" work", "Dev", "dev", "", "alpha"], now: now) | |
| 11 | #expect(e.tags == ["alpha", "Dev", "work"]) | |
| 12 | #expect(e.created == Date(timeIntervalSince1970: 1_700_000_000)) | |
| 13 | #expect(e.updated == e.created) | |
| 14 | } | |
| 15 | ||
| 16 | @Test func normalizeSortsCaseInsensitivelyAndKeepsFirstSpelling() { | |
| 17 | #expect(Entry.normalize(tags: ["b", "A", "a", "B"]) == ["A", "b"]) | |
| 18 | #expect(Entry.normalize(tags: []) == []) | |
| 19 | } | |
| 20 | ||
| 21 | @Test func hasTagIsCaseInsensitive() { | |
| 22 | let e = Entry(name: "gh", password: "p", tags: ["Dev"]) | |
| 23 | #expect(e.hasTag("dev")) | |
| 24 | #expect(e.hasTag("DEV")) | |
| 25 | #expect(!e.hasTag("ops")) | |
| 26 | } | |
| 27 | ||
| 28 | @Test func matchesSearchesEveryTextFieldExceptPassword() { | |
| 29 | let e = Entry( | |
| 30 | name: "GitHub", username: "cmc", password: "hunter2", url: "https://github.com", | |
| 31 | notes: "downtown office", tags: ["Dev"]) | |
| 32 | #expect(e.matches("github")) | |
| 33 | #expect(e.matches("CMC")) | |
| 34 | #expect(e.matches("github.com")) | |
| 35 | #expect(e.matches("downtown")) | |
| 36 | #expect(e.matches("dev")) | |
| 37 | #expect(!e.matches("hunter2")) | |
| 38 | #expect(!e.matches("nothing")) | |
| 39 | } | |
| 40 | } | |
Tests/KeycaskCoreTests/EnvelopeTests.swift added +119
| @@ -0,0 +1,119 @@ | ||
| 1 | import Crypto | |
| 2 | import Foundation | |
| 3 | import Testing | |
| 4 | ||
| 5 | @testable import KeycaskCore | |
| 6 | ||
| 7 | @Suite struct EnvelopeTests { | |
| 8 | // Low iteration count keeps the suite fast. Production uses Envelope.defaultIterations. | |
| 9 | let kdf = Envelope.KDFParams( | |
| 10 | name: Envelope.kdfName, iterations: 1_000, salt: Data(repeating: 7, count: 16)) | |
| 11 | ||
| 12 | func hex(_ key: SymmetricKey) -> String { | |
| 13 | key.withUnsafeBytes { $0.map { String(format: "%02x", $0) }.joined() } | |
| 14 | } | |
| 15 | ||
| 16 | @Test func pbkdf2MatchesPublishedVectors() throws { | |
| 17 | let one = Envelope.KDFParams(name: Envelope.kdfName, iterations: 1, salt: Data("salt".utf8)) | |
| 18 | #expect( | |
| 19 | hex(try Envelope.deriveKey(passphrase: "password", kdf: one)) | |
| 20 | == "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") | |
| 21 | let many = Envelope.KDFParams( | |
| 22 | name: Envelope.kdfName, iterations: 4096, salt: Data("salt".utf8)) | |
| 23 | #expect( | |
| 24 | hex(try Envelope.deriveKey(passphrase: "password", kdf: many)) | |
| 25 | == "c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a") | |
| 26 | } | |
| 27 | ||
| 28 | @Test func sealThenOpenRoundTrips() throws { | |
| 29 | let env = try Envelope.seal(Data("hello vault".utf8), passphrase: "pw", kdf: kdf) | |
| 30 | #expect(env.format == 1) | |
| 31 | #expect(env.kdf == kdf) | |
| 32 | #expect(try env.open(passphrase: "pw") == Data("hello vault".utf8)) | |
| 33 | } | |
| 34 | ||
| 35 | @Test func wrongPassphraseCannotDecrypt() throws { | |
| 36 | let env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 37 | #expect(throws: KeycaskError.cannotDecrypt) { try env.open(passphrase: "PW") } | |
| 38 | } | |
| 39 | ||
| 40 | @Test func tamperedBoxCannotDecrypt() throws { | |
| 41 | var env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 42 | env.box[env.box.count - 1] ^= 0x01 | |
| 43 | #expect(throws: KeycaskError.cannotDecrypt) { try env.open(passphrase: "pw") } | |
| 44 | } | |
| 45 | ||
| 46 | @Test func nonceIsFreshAndSaltIsKept() throws { | |
| 47 | let a = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 48 | let b = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 49 | #expect(a.box != b.box) | |
| 50 | #expect(a.kdf.salt == b.kdf.salt) | |
| 51 | } | |
| 52 | ||
| 53 | @Test func freshParamsUseDefaults() { | |
| 54 | let p = Envelope.KDFParams.fresh() | |
| 55 | #expect(p.name == "pbkdf2-hmac-sha256") | |
| 56 | #expect(p.iterations == 600_000) | |
| 57 | #expect(p.salt.count == 16) | |
| 58 | #expect(p.salt != Envelope.KDFParams.fresh().salt) | |
| 59 | } | |
| 60 | ||
| 61 | @Test func encodedShapeMatchesTheSpec() throws { | |
| 62 | let env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 63 | let json = try JSONSerialization.jsonObject(with: env.encoded()) as! [String: Any] | |
| 64 | #expect(json["format"] as? Int == 1) | |
| 65 | let k = json["kdf"] as! [String: Any] | |
| 66 | #expect(k["name"] as? String == "pbkdf2-hmac-sha256") | |
| 67 | #expect(k["iterations"] as? Int == 1_000) | |
| 68 | #expect(Data(base64Encoded: k["salt"] as! String) == kdf.salt) | |
| 69 | #expect(Data(base64Encoded: json["box"] as! String) == env.box) | |
| 70 | #expect(try Envelope(parsing: env.encoded()) == env) | |
| 71 | } | |
| 72 | ||
| 73 | @Test func malformedInputsAreCorrupt() throws { | |
| 74 | #expect(throws: KeycaskError.self) { try Envelope(parsing: Data("not json".utf8)) } | |
| 75 | #expect(throws: KeycaskError.self) { try Envelope(parsing: Data("{\"format\":1}".utf8)) } | |
| 76 | ||
| 77 | var wrongFormat = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 78 | wrongFormat.format = 2 | |
| 79 | #expect(throws: KeycaskError.corrupt("unsupported format 2")) { | |
| 80 | try wrongFormat.open(passphrase: "pw") | |
| 81 | } | |
| 82 | ||
| 83 | var wrongKDF = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 84 | wrongKDF.kdf.name = "argon2id" | |
| 85 | #expect(throws: KeycaskError.corrupt("unsupported kdf argon2id")) { | |
| 86 | try wrongKDF.open(passphrase: "pw") | |
| 87 | } | |
| 88 | ||
| 89 | var shortBox = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 90 | shortBox.box = Data([1, 2, 3]) | |
| 91 | #expect(throws: KeycaskError.corrupt("box too short")) { | |
| 92 | try shortBox.open(passphrase: "pw") | |
| 93 | } | |
| 94 | } | |
| 95 | ||
| 96 | @Test func outOfRangeIterationsAreCorrupt() throws { | |
| 97 | var env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 98 | env.kdf.iterations = -1 | |
| 99 | #expect(throws: KeycaskError.corrupt("bad iteration count -1")) { | |
| 100 | try env.open(passphrase: "pw") | |
| 101 | } | |
| 102 | env.kdf.iterations = 0 | |
| 103 | #expect(throws: KeycaskError.corrupt("bad iteration count 0")) { | |
| 104 | try env.open(passphrase: "pw") | |
| 105 | } | |
| 106 | let tooMany = Envelope.KDFParams( | |
| 107 | name: Envelope.kdfName, iterations: Int(UInt32.max) + 1, salt: kdf.salt) | |
| 108 | #expect(throws: KeycaskError.corrupt("bad iteration count \(Int(UInt32.max) + 1)")) { | |
| 109 | try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: tooMany) | |
| 110 | } | |
| 111 | } | |
| 112 | ||
| 113 | @Test func passphraseIsNFCNormalized() throws { | |
| 114 | let composed = "caf\u{00E9}" | |
| 115 | let decomposed = "cafe\u{0301}" | |
| 116 | let env = try Envelope.seal(Data("x".utf8), passphrase: composed, kdf: kdf) | |
| 117 | #expect(try env.open(passphrase: decomposed) == Data("x".utf8)) | |
| 118 | } | |
| 119 | } | |
Tests/KeycaskCoreTests/GeneratorTests.swift added +57
| @@ -0,0 +1,57 @@ | ||
| 1 | import Testing | |
| 2 | ||
| 3 | @testable import KeycaskCore | |
| 4 | ||
| 5 | @Suite struct GeneratorTests { | |
| 6 | struct Counter: RandomNumberGenerator { | |
| 7 | var n: UInt64 = 0 | |
| 8 | mutating func next() -> UInt64 { | |
| 9 | n &+= 0x9E37_79B9_7F4A_7C15 | |
| 10 | return n | |
| 11 | } | |
| 12 | } | |
| 13 | ||
| 14 | @Test func wordlistHas7776UniqueWords() { | |
| 15 | #expect(Wordlist.words.count == 7776) | |
| 16 | #expect(Set(Wordlist.words).count == 7776) | |
| 17 | #expect(Wordlist.words.first == "abacus") | |
| 18 | #expect(Wordlist.words.allSatisfy { !$0.isEmpty && !$0.contains(" ") }) | |
| 19 | } | |
| 20 | ||
| 21 | @Test func passwordHasRequestedLengthFromTheAlphabet() { | |
| 22 | let allowed = Set(Generator.alphabet) | |
| 23 | for length in [1, 8, 24, 64] { | |
| 24 | let p = Generator.password(length: length) | |
| 25 | #expect(p.count == length) | |
| 26 | #expect(p.allSatisfy { allowed.contains($0) }) | |
| 27 | } | |
| 28 | #expect(Generator.password(length: 0) == "") | |
| 29 | } | |
| 30 | ||
| 31 | @Test func alphabetCoversAllClasses() { | |
| 32 | let s = String(Generator.alphabet) | |
| 33 | #expect(s.contains("A") && s.contains("z") && s.contains("7") && s.contains("!")) | |
| 34 | #expect(Set(Generator.alphabet).count == Generator.alphabet.count) | |
| 35 | } | |
| 36 | ||
| 37 | @Test func passphraseUsesWordsFromTheList() { | |
| 38 | var a = Counter() | |
| 39 | var b = Counter() | |
| 40 | let produced = Generator.passphrase(words: 5, using: &a) | |
| 41 | let count = UInt32(Wordlist.words.count) | |
| 42 | let expected = (0..<5).map { _ in Wordlist.words[Int(b.next(upperBound: count))] } | |
| 43 | .joined(separator: Generator.wordSeparator) | |
| 44 | #expect(produced == expected) | |
| 45 | #expect(Generator.passphrase(words: 0) == "") | |
| 46 | #expect(!Generator.passphrase(words: 3).isEmpty) | |
| 47 | } | |
| 48 | ||
| 49 | @Test func seededOutputIsReproducible() { | |
| 50 | var a = Counter() | |
| 51 | var b = Counter() | |
| 52 | #expect( | |
| 53 | Generator.password(length: 16, using: &a) == Generator.password(length: 16, using: &b)) | |
| 54 | #expect( | |
| 55 | Generator.passphrase(words: 3, using: &a) == Generator.passphrase(words: 3, using: &b)) | |
| 56 | } | |
| 57 | } | |
Tests/KeycaskCoreTests/KeycaskErrorTests.swift added +38
| @@ -0,0 +1,38 @@ | ||
| 1 | import Testing | |
| 2 | ||
| 3 | @testable import KeycaskCore | |
| 4 | ||
| 5 | @Suite struct KeycaskErrorTests { | |
| 6 | @Test func exitCodesFollowTheSpec() { | |
| 7 | #expect(KeycaskError.failure("x").exitCode == 1) | |
| 8 | #expect(KeycaskError.io("x").exitCode == 1) | |
| 9 | #expect(KeycaskError.corrupt("x").exitCode == 1) | |
| 10 | #expect(KeycaskError.vaultExists("x").exitCode == 1) | |
| 11 | #expect(KeycaskError.duplicateID(EntryID("abcd2345")!).exitCode == 1) | |
| 12 | #expect(KeycaskError.usage("x").exitCode == 2) | |
| 13 | #expect(KeycaskError.notFound("x").exitCode == 3) | |
| 14 | #expect(KeycaskError.noVault("/p").exitCode == 3) | |
| 15 | #expect(KeycaskError.cannotDecrypt.exitCode == 4) | |
| 16 | #expect(KeycaskError.ambiguous(name: "gh", candidates: []).exitCode == 5) | |
| 17 | } | |
| 18 | ||
| 19 | @Test func messagesNameTheSubject() { | |
| 20 | #expect(KeycaskError.notFound("gh").message == "gh: not found") | |
| 21 | #expect(KeycaskError.noVault("/v").message == "vault /v not found (run `keycask init`)") | |
| 22 | #expect(KeycaskError.vaultExists("/v").message == "vault /v already exists") | |
| 23 | #expect( | |
| 24 | KeycaskError.cannotDecrypt.message | |
| 25 | == "cannot decrypt: wrong passphrase or damaged vault") | |
| 26 | #expect(KeycaskError.corrupt("bad json").message == "vault is corrupt: bad json") | |
| 27 | } | |
| 28 | ||
| 29 | @Test func ambiguousListsCandidateIDs() { | |
| 30 | let a = Entry(id: EntryID("aaaa2222")!, name: "gh", username: "one", password: "p") | |
| 31 | let b = Entry(id: EntryID("bbbb3333")!, name: "gh", password: "p", url: "https://x") | |
| 32 | let m = KeycaskError.ambiguous(name: "gh", candidates: [a, b]).message | |
| 33 | #expect(m.hasPrefix("gh: ambiguous, use an id:\n")) | |
| 34 | #expect(m.contains("aaaa2222")) | |
| 35 | #expect(m.contains("bbbb3333")) | |
| 36 | #expect(m.contains("https://x")) | |
| 37 | } | |
| 38 | } | |
Tests/KeycaskCoreTests/VaultCodecTests.swift added +52
| @@ -0,0 +1,52 @@ | ||
| 1 | import Foundation | |
| 2 | import Testing | |
| 3 | ||
| 4 | @testable import KeycaskCore | |
| 5 | ||
| 6 | @Suite struct VaultCodecTests { | |
| 7 | @Test func roundTripsAndIsDeterministic() throws { | |
| 8 | var v = Vault() | |
| 9 | try v.add( | |
| 10 | Entry( | |
| 11 | id: EntryID("aaaa2222")!, name: "gh", username: "cmc", password: "p", | |
| 12 | url: "https://github.com", notes: "n", tags: ["dev"], | |
| 13 | now: Date(timeIntervalSince1970: 1_700_000_000))) | |
| 14 | let a = try VaultCodec.encode(v) | |
| 15 | let b = try VaultCodec.encode(v) | |
| 16 | #expect(a == b) | |
| 17 | #expect(try VaultCodec.decode(a) == v) | |
| 18 | } | |
| 19 | ||
| 20 | @Test func datesAreISO8601WholeSeconds() throws { | |
| 21 | var v = Vault() | |
| 22 | try v.add( | |
| 23 | Entry( | |
| 24 | id: EntryID("aaaa2222")!, name: "gh", password: "p", | |
| 25 | now: Date(timeIntervalSince1970: 1_700_000_000))) | |
| 26 | let text = String(decoding: try VaultCodec.encode(v), as: UTF8.self) | |
| 27 | #expect(text.contains("\"created\":\"2023-11-14T22:13:20Z\"")) | |
| 28 | } | |
| 29 | ||
| 30 | @Test func keysAreSorted() throws { | |
| 31 | var v = Vault() | |
| 32 | try v.add(Entry(id: EntryID("aaaa2222")!, name: "gh", password: "p")) | |
| 33 | let text = String(decoding: try VaultCodec.encode(v), as: UTF8.self) | |
| 34 | let created = text.range(of: "\"created\"")!.lowerBound | |
| 35 | let id = text.range(of: "\"id\"")!.lowerBound | |
| 36 | let updated = text.range(of: "\"updated\"")!.lowerBound | |
| 37 | #expect(created < id && id < updated) | |
| 38 | } | |
| 39 | ||
| 40 | @Test func garbageIsCorrupt() { | |
| 41 | #expect(throws: KeycaskError.self) { try VaultCodec.decode(Data("nope".utf8)) } | |
| 42 | do { | |
| 43 | _ = try VaultCodec.decode(Data("{\"entries\":[{\"id\":1}]}".utf8)) | |
| 44 | Issue.record("expected corrupt") | |
| 45 | } catch let e as KeycaskError { | |
| 46 | #expect(e.exitCode == 1) | |
| 47 | #expect(e.message.hasPrefix("vault is corrupt:")) | |
| 48 | } catch { | |
| 49 | Issue.record("wrong error \(error)") | |
| 50 | } | |
| 51 | } | |
| 52 | } | |
Tests/KeycaskCoreTests/VaultTests.swift added +88
| @@ -0,0 +1,88 @@ | ||
| 1 | import Foundation | |
| 2 | import Testing | |
| 3 | ||
| 4 | @testable import KeycaskCore | |
| 5 | ||
| 6 | @Suite struct VaultTests { | |
| 7 | func idA() -> EntryID { EntryID("aaaa2222")! } | |
| 8 | func idB() -> EntryID { EntryID("bbbb3333")! } | |
| 9 | ||
| 10 | @Test func addRejectsDuplicateID() throws { | |
| 11 | var v = Vault() | |
| 12 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 13 | #expect(throws: KeycaskError.duplicateID(idA())) { | |
| 14 | try v.add(Entry(id: idA(), name: "other", password: "p")) | |
| 15 | } | |
| 16 | #expect(v.entries.count == 1) | |
| 17 | } | |
| 18 | ||
| 19 | @Test func removeUnknownIsNotFound() { | |
| 20 | var v = Vault() | |
| 21 | #expect(throws: KeycaskError.notFound("aaaa2222")) { try v.remove(id: idA()) } | |
| 22 | } | |
| 23 | ||
| 24 | @Test func updateSetsUpdatedAndNormalizesTags() throws { | |
| 25 | let t0 = Date(timeIntervalSince1970: 1_000) | |
| 26 | let t1 = Date(timeIntervalSince1970: 2_000.9) | |
| 27 | var v = Vault() | |
| 28 | try v.add(Entry(id: idA(), name: "gh", password: "p", now: t0)) | |
| 29 | try v.update(id: idA(), now: t1) { e in | |
| 30 | e.tags = ["z", "A", "a"] | |
| 31 | e.password = "q" | |
| 32 | } | |
| 33 | let e = v.entry(id: idA())! | |
| 34 | #expect(e.password == "q") | |
| 35 | #expect(e.tags == ["A", "z"]) | |
| 36 | #expect(e.created == t0) | |
| 37 | #expect(e.updated == Date(timeIntervalSince1970: 2_000)) | |
| 38 | } | |
| 39 | ||
| 40 | @Test func resolvePrefersIDThenUniqueName() throws { | |
| 41 | var v = Vault() | |
| 42 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 43 | try v.add(Entry(id: idB(), name: "aaaa2222", password: "p")) | |
| 44 | #expect(try v.resolve("aaaa2222").id == idA()) | |
| 45 | #expect(try v.resolve("gh").id == idA()) | |
| 46 | #expect(try v.resolve("bbbb3333").id == idB()) | |
| 47 | } | |
| 48 | ||
| 49 | @Test func resolveReportsAmbiguousWithAllCandidates() throws { | |
| 50 | var v = Vault() | |
| 51 | let a = Entry(id: idA(), name: "gh", password: "p") | |
| 52 | let b = Entry(id: idB(), name: "gh", password: "p") | |
| 53 | try v.add(a) | |
| 54 | try v.add(b) | |
| 55 | #expect(throws: KeycaskError.ambiguous(name: "gh", candidates: [a, b])) { | |
| 56 | try v.resolve("gh") | |
| 57 | } | |
| 58 | } | |
| 59 | ||
| 60 | @Test func resolveUnknownIsNotFound() { | |
| 61 | #expect(throws: KeycaskError.notFound("nope")) { try Vault().resolve("nope") } | |
| 62 | } | |
| 63 | ||
| 64 | @Test func filterAndSearch() throws { | |
| 65 | var v = Vault() | |
| 66 | try v.add(Entry(id: idA(), name: "GitHub", password: "p", tags: ["dev"])) | |
| 67 | try v.add(Entry(id: idB(), name: "bank", password: "p", url: "https://bank.example")) | |
| 68 | #expect(v.filter(tag: "DEV").map(\.id) == [idA()]) | |
| 69 | #expect(v.search("example").map(\.id) == [idB()]) | |
| 70 | #expect(v.search("zzz").isEmpty) | |
| 71 | } | |
| 72 | ||
| 73 | @Test func sortedEntriesOrderByNameThenID() throws { | |
| 74 | var v = Vault() | |
| 75 | try v.add(Entry(id: idB(), name: "gh", password: "p")) | |
| 76 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 77 | try v.add(Entry(id: EntryID("cccc4444")!, name: "Alpha", password: "p")) | |
| 78 | #expect(v.sortedEntries.map(\.id.rawValue) == ["cccc4444", "aaaa2222", "bbbb3333"]) | |
| 79 | } | |
| 80 | ||
| 81 | @Test func addNormalizesTagsSetAfterInit() throws { | |
| 82 | var e = Entry(id: idA(), name: "gh", password: "p") | |
| 83 | e.tags = ["z", "A", "a", " b "] | |
| 84 | var v = Vault() | |
| 85 | try v.add(e) | |
| 86 | #expect(v.entry(id: idA())!.tags == ["A", "b", "z"]) | |
| 87 | } | |
| 88 | } | |
docs/superpowers/plans/2026-09-17-core-cli.md added +3337
| @@ -0,0 +1,3337 @@ | ||
| 1 | # keycask core + CLI Implementation Plan | |
| 2 | ||
| 3 | > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. | |
| 4 | ||
| 5 | **Goal:** A Swift package with `KeycaskCore` (vault model, passphrase-encrypted envelope, generator, resolution) and a `keycask` CLI that behaves identically on macOS, Linux, and Windows, covered by in-process and black-box tests. | |
| 6 | ||
| 7 | **Architecture:** `KeycaskCore` depends on Foundation and swift-crypto only and holds every rule about entries, IDs, encryption, and lookup. The `keycask` executable wraps it with ArgumentParser commands and a small platform layer (paths, terminal, atomic write, clipboard). Tests in `KeycaskCoreTests` run in process; tests in `KeycaskCLITests` spawn the built binary and check stdout, stderr, and exit codes. | |
| 8 | ||
| 9 | **Tech Stack:** Swift 6.4, SwiftPM, Swift Testing, swift-crypto 3.15 (`Crypto`, `_CryptoExtras`), swift-argument-parser 1.8. | |
| 10 | ||
| 11 | **Spec:** `docs/superpowers/specs/2026-09-17-keycask-design.md` | |
| 12 | ||
| 13 | ## Global Constraints | |
| 14 | ||
| 15 | - `// swift-tools-version:6.4`, Swift 6 language mode, `platforms: [.macOS(.v14), .iOS(.v17)]`. | |
| 16 | - Dependencies are exactly `apple/swift-crypto` and `apple/swift-argument-parser`. `Package.resolved` is committed. | |
| 17 | - `KeycaskCore` imports only `Foundation`, `Crypto`, and `_CryptoExtras`. It never imports ArgumentParser, never spawns a process, never reads the environment. | |
| 18 | - Envelope: `format` 1, `kdf.name` `"pbkdf2-hmac-sha256"`, 600000 iterations, 16-byte salt, ChaCha20-Poly1305 combined box, key 32 bytes, passphrase NFC-normalized UTF-8. | |
| 19 | - `EntryID`: 8 characters from `abcdefghijkmnpqrstuvwxyz23456789`. | |
| 20 | - Dates: ISO 8601 UTC, whole seconds. JSON: sorted keys. | |
| 21 | - Exit codes: 0 ok, 1 failure, 2 usage, 3 not found, 4 cannot decrypt, 5 ambiguous. | |
| 22 | - Masked secret string is exactly `********`. | |
| 23 | - Clipboard timeout is 45 seconds. Password default length 24. Passphrase separator `-`. | |
| 24 | - No code comments that mention the history of the project or how it used to work. No attribution trailers in commits. | |
| 25 | - Every file passes `swift format lint --strict`. | |
| 26 | - Work happens on a branch. Tasks 1-8 go on branch `core`, merged through one MR. Tasks 9-15 go on branch `cli`, merged through a second MR. Never commit to `main` directly. | |
| 27 | ||
| 28 | ## File structure | |
| 29 | ||
| 30 | ``` | |
| 31 | Package.swift | |
| 32 | Package.resolved | |
| 33 | NOTICE | |
| 34 | .gitbay/ci.yml | |
| 35 | Sources/KeycaskCore/ | |
| 36 | KeycaskError.swift error enum, exit codes, messages | |
| 37 | EntryID.swift 8-char random ID, Codable as a string | |
| 38 | Entry.swift entry struct, tag normalization, second-truncated dates | |
| 39 | Vault.swift entries, add/remove/update, resolve, filter, search | |
| 40 | VaultCodec.swift deterministic JSON encode/decode of Vault | |
| 41 | Envelope.swift file envelope, PBKDF2 + ChaChaPoly seal/open, parse/encode | |
| 42 | Generator.swift random password and passphrase | |
| 43 | Wordlist.swift EFF long list as one string literal (generated file) | |
| 44 | Sources/keycask/ | |
| 45 | main.swift parse, run, map errors to exit codes | |
| 46 | Keycask.swift root command, GlobalOptions | |
| 47 | Paths.swift vault path resolution | |
| 48 | Terminal.swift isatty, echo-off line read, y/N confirm | |
| 49 | Passphrase.swift env var or prompt | |
| 50 | AtomicFile.swift temp + fsync + rename, 0600 on Unix, MoveFileExW on Windows | |
| 51 | OpenVault.swift load/save/create: ties paths, passphrase, envelope, codec, atomic write | |
| 52 | Output.swift text, table, JSON, masking, --field | |
| 53 | Clipboard.swift tool discovery, read/write, daemon handoff | |
| 54 | Commands/Init.swift | |
| 55 | Commands/Add.swift | |
| 56 | Commands/Show.swift | |
| 57 | Commands/Ls.swift | |
| 58 | Commands/Find.swift | |
| 59 | Commands/Edit.swift | |
| 60 | Commands/Rm.swift | |
| 61 | Commands/Generate.swift | |
| 62 | Commands/Clip.swift | |
| 63 | Commands/ClipboardDaemon.swift | |
| 64 | Tests/KeycaskCoreTests/ | |
| 65 | EntryIDTests.swift | |
| 66 | EntryTests.swift | |
| 67 | VaultTests.swift | |
| 68 | VaultCodecTests.swift | |
| 69 | EnvelopeTests.swift | |
| 70 | GeneratorTests.swift | |
| 71 | KeycaskErrorTests.swift | |
| 72 | Tests/KeycaskCLITests/ | |
| 73 | CLI.swift harness: locate binary, temp vault, run with env | |
| 74 | InitTests.swift | |
| 75 | AddShowTests.swift | |
| 76 | LsFindTests.swift | |
| 77 | EditRmTests.swift | |
| 78 | GenerateTests.swift | |
| 79 | ClipboardTests.swift | |
| 80 | PathsTests.swift | |
| 81 | ``` | |
| 82 | ||
| 83 | --- | |
| 84 | ||
| 85 | ### Task 1: Package scaffold and CI | |
| 86 | ||
| 87 | **Files:** | |
| 88 | - Create: `Package.swift` | |
| 89 | - Create: `Sources/KeycaskCore/KeycaskCore.swift` (temporary, deleted in Task 2) | |
| 90 | - Create: `Sources/keycask/main.swift` (replaced in Task 9) | |
| 91 | - Create: `Tests/KeycaskCoreTests/SmokeTests.swift` (deleted in Task 2) | |
| 92 | - Create: `.gitbay/ci.yml` | |
| 93 | - Create: `.swift-format` | |
| 94 | ||
| 95 | **Interfaces:** | |
| 96 | - Produces: the package layout every later task adds files to. | |
| 97 | ||
| 98 | - [ ] **Step 1: Create the branch** | |
| 99 | ||
| 100 | ```bash | |
| 101 | cd /Users/cmc/git/krz/keycask && git switch -c core | |
| 102 | ``` | |
| 103 | ||
| 104 | - [ ] **Step 2: Write Package.swift** | |
| 105 | ||
| 106 | ```swift | |
| 107 | // swift-tools-version:6.4 | |
| 108 | import PackageDescription | |
| 109 | ||
| 110 | let package = Package( | |
| 111 | name: "keycask", | |
| 112 | platforms: [.macOS(.v14), .iOS(.v17)], | |
| 113 | products: [ | |
| 114 | .library(name: "KeycaskCore", targets: ["KeycaskCore"]), | |
| 115 | .executable(name: "keycask", targets: ["keycask"]), | |
| 116 | ], | |
| 117 | dependencies: [ | |
| 118 | .package(url: "https://github.com/apple/swift-crypto", from: "3.15.0"), | |
| 119 | .package(url: "https://github.com/apple/swift-argument-parser", from: "1.8.0"), | |
| 120 | ], | |
| 121 | targets: [ | |
| 122 | .target( | |
| 123 | name: "KeycaskCore", | |
| 124 | dependencies: [ | |
| 125 | .product(name: "Crypto", package: "swift-crypto"), | |
| 126 | .product(name: "_CryptoExtras", package: "swift-crypto"), | |
| 127 | ] | |
| 128 | ), | |
| 129 | .executableTarget( | |
| 130 | name: "keycask", | |
| 131 | dependencies: [ | |
| 132 | "KeycaskCore", | |
| 133 | .product(name: "ArgumentParser", package: "swift-argument-parser"), | |
| 134 | ] | |
| 135 | ), | |
| 136 | .testTarget(name: "KeycaskCoreTests", dependencies: ["KeycaskCore"]), | |
| 137 | .testTarget(name: "KeycaskCLITests", dependencies: ["keycask"]), | |
| 138 | ] | |
| 139 | ) | |
| 140 | ``` | |
| 141 | ||
| 142 | - [ ] **Step 3: Write placeholder sources so the package builds** | |
| 143 | ||
| 144 | `Sources/KeycaskCore/KeycaskCore.swift`: | |
| 145 | ||
| 146 | ```swift | |
| 147 | public enum KeycaskCore { | |
| 148 | public static let name = "keycask" | |
| 149 | } | |
| 150 | ``` | |
| 151 | ||
| 152 | `Sources/keycask/main.swift`: | |
| 153 | ||
| 154 | ```swift | |
| 155 | import KeycaskCore | |
| 156 | ||
| 157 | print(KeycaskCore.name) | |
| 158 | ``` | |
| 159 | ||
| 160 | `Tests/KeycaskCoreTests/SmokeTests.swift`: | |
| 161 | ||
| 162 | ```swift | |
| 163 | import Testing | |
| 164 | ||
| 165 | @testable import KeycaskCore | |
| 166 | ||
| 167 | @Test func packageBuilds() { | |
| 168 | #expect(KeycaskCore.name == "keycask") | |
| 169 | } | |
| 170 | ``` | |
| 171 | ||
| 172 | `Tests/KeycaskCLITests/CLI.swift` (a real file, extended in Task 9; this version only locates the binary): | |
| 173 | ||
| 174 | ```swift | |
| 175 | import Foundation | |
| 176 | import Testing | |
| 177 | ||
| 178 | enum Binary { | |
| 179 | static let url: URL = { | |
| 180 | #if os(macOS) | |
| 181 | for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { | |
| 182 | return bundle.bundleURL.deletingLastPathComponent().appendingPathComponent("keycask") | |
| 183 | } | |
| 184 | fatalError("test bundle not found") | |
| 185 | #elseif os(Windows) | |
| 186 | return Bundle.main.bundleURL.appendingPathComponent("keycask.exe") | |
| 187 | #else | |
| 188 | return Bundle.main.bundleURL.appendingPathComponent("keycask") | |
| 189 | #endif | |
| 190 | }() | |
| 191 | } | |
| 192 | ||
| 193 | @Test func binaryIsBuilt() { | |
| 194 | #expect(FileManager.default.isExecutableFile(atPath: Binary.url.path)) | |
| 195 | } | |
| 196 | ``` | |
| 197 | ||
| 198 | - [ ] **Step 4: Write .swift-format** | |
| 199 | ||
| 200 | ```json | |
| 201 | { | |
| 202 | "version": 1, | |
| 203 | "indentation": { "spaces": 4 }, | |
| 204 | "lineLength": 100, | |
| 205 | "maximumBlankLines": 1, | |
| 206 | "respectsExistingLineBreaks": true, | |
| 207 | "rules": { | |
| 208 | "AlwaysUseLowerCamelCase": true, | |
| 209 | "NeverForceUnwrap": false, | |
| 210 | "NeverUseImplicitlyUnwrappedOptionals": true | |
| 211 | } | |
| 212 | } | |
| 213 | ``` | |
| 214 | ||
| 215 | - [ ] **Step 5: Build and test** | |
| 216 | ||
| 217 | Run: `swift build && swift test` | |
| 218 | Expected: `Build complete`, two tests pass. `Package.resolved` now exists. | |
| 219 | ||
| 220 | - [ ] **Step 6: Lint** | |
| 221 | ||
| 222 | Run: `swift format lint --strict --recursive Sources Tests Package.swift` | |
| 223 | Expected: no output. If it reports findings, run `swift format --in-place --recursive Sources Tests Package.swift` and re-lint. | |
| 224 | ||
| 225 | - [ ] **Step 7: Write .gitbay/ci.yml** | |
| 226 | ||
| 227 | ```yaml | |
| 228 | # Each step runs in its own `sh -c`; exports do not survive between steps. | |
| 229 | # swiftly installs into $HOME, which persists across builds. | |
| 230 | jobs: | |
| 231 | build: | |
| 232 | steps: | |
| 233 | - | | |
| 234 | set -eu | |
| 235 | command -v curl >/dev/null || { echo "runner is missing: curl"; exit 1; } | |
| 236 | if ! command -v "$HOME/.local/bin/swiftly" >/dev/null 2>&1; then | |
| 237 | curl -fsSL "https://download.swift.org/swiftly/linux/swiftly-$(uname -m).tar.gz" | tar -xz -C /tmp | |
| 238 | /tmp/swiftly init --assume-yes --skip-install --quiet-shell-followup | |
| 239 | fi | |
| 240 | . "$HOME/.local/share/swiftly/env.sh" | |
| 241 | swiftly install --use 6.4 | |
| 242 | swift format lint --strict --recursive Sources Tests Package.swift | |
| 243 | swift build | |
| 244 | test: | |
| 245 | steps: | |
| 246 | - | | |
| 247 | set -eu | |
| 248 | . "$HOME/.local/share/swiftly/env.sh" | |
| 249 | swiftly install --use 6.4 | |
| 250 | swift test | |
| 251 | paths-ignore: | |
| 252 | - docs/** | |
| 253 | ``` | |
| 254 | ||
| 255 | - [ ] **Step 8: Commit** | |
| 256 | ||
| 257 | ```bash | |
| 258 | git add Package.swift Package.resolved .swift-format .gitbay/ci.yml Sources Tests | |
| 259 | git commit -m "Add package scaffold and CI" | |
| 260 | ``` | |
| 261 | ||
| 262 | --- | |
| 263 | ||
| 264 | ### Task 2: KeycaskError | |
| 265 | ||
| 266 | **Files:** | |
| 267 | - Create: `Sources/KeycaskCore/KeycaskError.swift` | |
| 268 | - Create: `Tests/KeycaskCoreTests/KeycaskErrorTests.swift` | |
| 269 | - Delete: `Sources/KeycaskCore/KeycaskCore.swift`, `Tests/KeycaskCoreTests/SmokeTests.swift` | |
| 270 | ||
| 271 | **Interfaces:** | |
| 272 | - Produces: `public enum KeycaskError: Error, Equatable, Sendable` with cases `notFound(String)`, `ambiguous(name: String, candidates: [Entry])`, `cannotDecrypt`, `corrupt(String)`, `vaultExists(String)`, `noVault(String)`, `duplicateID(EntryID)`, `io(String)`, `usage(String)`, `failure(String)`; properties `exitCode: Int32`, `message: String`. | |
| 273 | - Note: `Entry` and `EntryID` do not exist yet. Write this task with `ambiguous(name: String, candidates: [String])` and `duplicateID(String)` and change them to the real types in Tasks 3 and 4. | |
| 274 | ||
| 275 | - [ ] **Step 1: Delete placeholders** | |
| 276 | ||
| 277 | ```bash | |
| 278 | git rm -q Sources/KeycaskCore/KeycaskCore.swift Tests/KeycaskCoreTests/SmokeTests.swift | |
| 279 | ``` | |
| 280 | ||
| 281 | - [ ] **Step 2: Write the failing test** | |
| 282 | ||
| 283 | `Tests/KeycaskCoreTests/KeycaskErrorTests.swift`: | |
| 284 | ||
| 285 | ```swift | |
| 286 | import Testing | |
| 287 | ||
| 288 | @testable import KeycaskCore | |
| 289 | ||
| 290 | @Suite struct KeycaskErrorTests { | |
| 291 | @Test func exitCodesFollowTheSpec() { | |
| 292 | #expect(KeycaskError.failure("x").exitCode == 1) | |
| 293 | #expect(KeycaskError.io("x").exitCode == 1) | |
| 294 | #expect(KeycaskError.corrupt("x").exitCode == 1) | |
| 295 | #expect(KeycaskError.vaultExists("x").exitCode == 1) | |
| 296 | #expect(KeycaskError.duplicateID("abcd2345").exitCode == 1) | |
| 297 | #expect(KeycaskError.usage("x").exitCode == 2) | |
| 298 | #expect(KeycaskError.notFound("x").exitCode == 3) | |
| 299 | #expect(KeycaskError.noVault("/p").exitCode == 3) | |
| 300 | #expect(KeycaskError.cannotDecrypt.exitCode == 4) | |
| 301 | #expect(KeycaskError.ambiguous(name: "gh", candidates: []).exitCode == 5) | |
| 302 | } | |
| 303 | ||
| 304 | @Test func messagesNameTheSubject() { | |
| 305 | #expect(KeycaskError.notFound("gh").message == "gh: not found") | |
| 306 | #expect(KeycaskError.noVault("/v").message == "vault /v not found (run `keycask init`)") | |
| 307 | #expect(KeycaskError.vaultExists("/v").message == "vault /v already exists") | |
| 308 | #expect(KeycaskError.cannotDecrypt.message == "cannot decrypt: wrong passphrase or damaged vault") | |
| 309 | #expect(KeycaskError.corrupt("bad json").message == "vault is corrupt: bad json") | |
| 310 | } | |
| 311 | } | |
| 312 | ``` | |
| 313 | ||
| 314 | - [ ] **Step 3: Run test to verify it fails** | |
| 315 | ||
| 316 | Run: `swift test --filter KeycaskErrorTests` | |
| 317 | Expected: compile error, `KeycaskError` not found. | |
| 318 | ||
| 319 | - [ ] **Step 4: Write the implementation** | |
| 320 | ||
| 321 | `Sources/KeycaskCore/KeycaskError.swift`: | |
| 322 | ||
| 323 | ```swift | |
| 324 | public enum KeycaskError: Error, Equatable, Sendable { | |
| 325 | case notFound(String) | |
| 326 | case ambiguous(name: String, candidates: [String]) | |
| 327 | case cannotDecrypt | |
| 328 | case corrupt(String) | |
| 329 | case vaultExists(String) | |
| 330 | case noVault(String) | |
| 331 | case duplicateID(String) | |
| 332 | case io(String) | |
| 333 | case usage(String) | |
| 334 | case failure(String) | |
| 335 | ||
| 336 | public var exitCode: Int32 { | |
| 337 | switch self { | |
| 338 | case .failure, .io, .corrupt, .vaultExists, .duplicateID: 1 | |
| 339 | case .usage: 2 | |
| 340 | case .notFound, .noVault: 3 | |
| 341 | case .cannotDecrypt: 4 | |
| 342 | case .ambiguous: 5 | |
| 343 | } | |
| 344 | } | |
| 345 | ||
| 346 | public var message: String { | |
| 347 | switch self { | |
| 348 | case .notFound(let what): "\(what): not found" | |
| 349 | case .ambiguous(let name, let candidates): | |
| 350 | (["\(name): ambiguous, use an id:"] + candidates).joined(separator: "\n") | |
| 351 | case .cannotDecrypt: "cannot decrypt: wrong passphrase or damaged vault" | |
| 352 | case .corrupt(let why): "vault is corrupt: \(why)" | |
| 353 | case .vaultExists(let path): "vault \(path) already exists" | |
| 354 | case .noVault(let path): "vault \(path) not found (run `keycask init`)" | |
| 355 | case .duplicateID(let id): "duplicate id \(id)" | |
| 356 | case .io(let why): why | |
| 357 | case .usage(let why): why | |
| 358 | case .failure(let why): why | |
| 359 | } | |
| 360 | } | |
| 361 | } | |
| 362 | ``` | |
| 363 | ||
| 364 | - [ ] **Step 5: Run tests** | |
| 365 | ||
| 366 | Run: `swift test --filter KeycaskErrorTests` | |
| 367 | Expected: 2 tests pass. | |
| 368 | ||
| 369 | - [ ] **Step 6: Commit** | |
| 370 | ||
| 371 | ```bash | |
| 372 | git add -A Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 373 | git commit -m "Add KeycaskError with exit codes" | |
| 374 | ``` | |
| 375 | ||
| 376 | --- | |
| 377 | ||
| 378 | ### Task 3: EntryID | |
| 379 | ||
| 380 | **Files:** | |
| 381 | - Create: `Sources/KeycaskCore/EntryID.swift` | |
| 382 | - Create: `Tests/KeycaskCoreTests/EntryIDTests.swift` | |
| 383 | - Modify: `Sources/KeycaskCore/KeycaskError.swift` (`duplicateID(EntryID)`) | |
| 384 | - Modify: `Tests/KeycaskCoreTests/KeycaskErrorTests.swift` | |
| 385 | ||
| 386 | **Interfaces:** | |
| 387 | - Produces: `public struct EntryID: Hashable, Sendable, Codable, CustomStringConvertible` with `static let alphabet: [Character]`, `static let length = 8`, `let rawValue: String`, `init?(_ raw: String)`, `static func random() -> EntryID`, `static func random(using: inout some RandomNumberGenerator) -> EntryID`. Codable as a bare JSON string. | |
| 388 | ||
| 389 | - [ ] **Step 1: Write the failing test** | |
| 390 | ||
| 391 | `Tests/KeycaskCoreTests/EntryIDTests.swift`: | |
| 392 | ||
| 393 | ```swift | |
| 394 | import Foundation | |
| 395 | import Testing | |
| 396 | ||
| 397 | @testable import KeycaskCore | |
| 398 | ||
| 399 | @Suite struct EntryIDTests { | |
| 400 | @Test func randomIDsHaveLengthEightFromTheAlphabet() { | |
| 401 | let allowed = Set(EntryID.alphabet) | |
| 402 | for _ in 0..<200 { | |
| 403 | let id = EntryID.random() | |
| 404 | #expect(id.rawValue.count == 8) | |
| 405 | #expect(id.rawValue.allSatisfy { allowed.contains($0) }) | |
| 406 | } | |
| 407 | } | |
| 408 | ||
| 409 | @Test func alphabetExcludesAmbiguousCharacters() { | |
| 410 | let alphabet = Set(EntryID.alphabet) | |
| 411 | #expect(alphabet.count == 32) | |
| 412 | for bad in ["l", "o", "0", "1"] { | |
| 413 | #expect(!alphabet.contains(Character(bad))) | |
| 414 | } | |
| 415 | } | |
| 416 | ||
| 417 | @Test func parsingValidatesLengthAndAlphabet() { | |
| 418 | #expect(EntryID("abcd2345") != nil) | |
| 419 | #expect(EntryID("abcd234") == nil) | |
| 420 | #expect(EntryID("abcd23456") == nil) | |
| 421 | #expect(EntryID("abcd234l") == nil) | |
| 422 | #expect(EntryID("ABCD2345") == nil) | |
| 423 | } | |
| 424 | ||
| 425 | @Test func codableIsABareString() throws { | |
| 426 | let id = EntryID("abcd2345")! | |
| 427 | let data = try JSONEncoder().encode([id]) | |
| 428 | #expect(String(decoding: data, as: UTF8.self) == "[\"abcd2345\"]") | |
| 429 | let back = try JSONDecoder().decode([EntryID].self, from: data) | |
| 430 | #expect(back == [id]) | |
| 431 | #expect(throws: DecodingError.self) { | |
| 432 | try JSONDecoder().decode([EntryID].self, from: Data("[\"bad\"]".utf8)) | |
| 433 | } | |
| 434 | } | |
| 435 | ||
| 436 | @Test func seededGeneratorIsDeterministic() { | |
| 437 | struct Counter: RandomNumberGenerator { | |
| 438 | var n: UInt64 = 0 | |
| 439 | mutating func next() -> UInt64 { | |
| 440 | n += 1 | |
| 441 | return n | |
| 442 | } | |
| 443 | } | |
| 444 | var a = Counter() | |
| 445 | var b = Counter() | |
| 446 | #expect(EntryID.random(using: &a) == EntryID.random(using: &b)) | |
| 447 | } | |
| 448 | } | |
| 449 | ``` | |
| 450 | ||
| 451 | - [ ] **Step 2: Run test to verify it fails** | |
| 452 | ||
| 453 | Run: `swift test --filter EntryIDTests` | |
| 454 | Expected: compile error, `EntryID` not found. | |
| 455 | ||
| 456 | - [ ] **Step 3: Write the implementation** | |
| 457 | ||
| 458 | `Sources/KeycaskCore/EntryID.swift`: | |
| 459 | ||
| 460 | ```swift | |
| 461 | public struct EntryID: Hashable, Sendable, CustomStringConvertible { | |
| 462 | public static let alphabet: [Character] = Array("abcdefghijkmnpqrstuvwxyz23456789") | |
| 463 | public static let length = 8 | |
| 464 | ||
| 465 | public let rawValue: String | |
| 466 | ||
| 467 | public init?(_ raw: String) { | |
| 468 | guard raw.count == Self.length else { return nil } | |
| 469 | let allowed = Set(Self.alphabet) | |
| 470 | guard raw.allSatisfy({ allowed.contains($0) }) else { return nil } | |
| 471 | rawValue = raw | |
| 472 | } | |
| 473 | ||
| 474 | public static func random() -> EntryID { | |
| 475 | var rng = SystemRandomNumberGenerator() | |
| 476 | return random(using: &rng) | |
| 477 | } | |
| 478 | ||
| 479 | public static func random(using rng: inout some RandomNumberGenerator) -> EntryID { | |
| 480 | var chars: [Character] = [] | |
| 481 | chars.reserveCapacity(length) | |
| 482 | for _ in 0..<length { | |
| 483 | chars.append(alphabet[Int(rng.next(upperBound: UInt32(alphabet.count)))]) | |
| 484 | } | |
| 485 | return EntryID(String(chars))! | |
| 486 | } | |
| 487 | ||
| 488 | public var description: String { rawValue } | |
| 489 | } | |
| 490 | ||
| 491 | extension EntryID: Codable { | |
| 492 | public init(from decoder: any Decoder) throws { | |
| 493 | let raw = try decoder.singleValueContainer().decode(String.self) | |
| 494 | guard let id = EntryID(raw) else { | |
| 495 | throw DecodingError.dataCorrupted( | |
| 496 | .init(codingPath: decoder.codingPath, debugDescription: "invalid entry id \(raw)")) | |
| 497 | } | |
| 498 | self = id | |
| 499 | } | |
| 500 | ||
| 501 | public func encode(to encoder: any Encoder) throws { | |
| 502 | var container = encoder.singleValueContainer() | |
| 503 | try container.encode(rawValue) | |
| 504 | } | |
| 505 | } | |
| 506 | ``` | |
| 507 | ||
| 508 | - [ ] **Step 4: Switch `duplicateID` to the real type** | |
| 509 | ||
| 510 | In `KeycaskError.swift` change `case duplicateID(String)` to `case duplicateID(EntryID)` and the message to `"duplicate id \(id.rawValue)"`. In `KeycaskErrorTests.swift` change `.duplicateID("abcd2345")` to `.duplicateID(EntryID("abcd2345")!)`. | |
| 511 | ||
| 512 | - [ ] **Step 5: Run tests** | |
| 513 | ||
| 514 | Run: `swift test --filter 'EntryIDTests|KeycaskErrorTests'` | |
| 515 | Expected: 7 tests pass. | |
| 516 | ||
| 517 | - [ ] **Step 6: Commit** | |
| 518 | ||
| 519 | ```bash | |
| 520 | git add Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 521 | git commit -m "Add EntryID" | |
| 522 | ``` | |
| 523 | ||
| 524 | --- | |
| 525 | ||
| 526 | ### Task 4: Entry | |
| 527 | ||
| 528 | **Files:** | |
| 529 | - Create: `Sources/KeycaskCore/Entry.swift` | |
| 530 | - Create: `Tests/KeycaskCoreTests/EntryTests.swift` | |
| 531 | - Modify: `Sources/KeycaskCore/KeycaskError.swift` (`ambiguous(name:candidates: [Entry])`) | |
| 532 | - Modify: `Tests/KeycaskCoreTests/KeycaskErrorTests.swift` | |
| 533 | ||
| 534 | **Interfaces:** | |
| 535 | - Consumes: `EntryID`. | |
| 536 | - Produces: | |
| 537 | ||
| 538 | ```swift | |
| 539 | public struct Entry: Codable, Equatable, Sendable { | |
| 540 | public let id: EntryID | |
| 541 | public var name: String | |
| 542 | public var username: String? | |
| 543 | public var password: String | |
| 544 | public var url: String? | |
| 545 | public var notes: String? | |
| 546 | public var tags: [String] | |
| 547 | public let created: Date | |
| 548 | public var updated: Date | |
| 549 | ||
| 550 | public init(id: EntryID = .random(), name: String, username: String? = nil, | |
| 551 | password: String, url: String? = nil, notes: String? = nil, | |
| 552 | tags: [String] = [], now: Date = .now) | |
| 553 | public static func normalize(tags: [String]) -> [String] | |
| 554 | public static func truncateToSeconds(_ date: Date) -> Date | |
| 555 | public func hasTag(_ tag: String) -> Bool | |
| 556 | public func matches(_ query: String) -> Bool | |
| 557 | } | |
| 558 | ``` | |
| 559 | ||
| 560 | - [ ] **Step 1: Write the failing test** | |
| 561 | ||
| 562 | `Tests/KeycaskCoreTests/EntryTests.swift`: | |
| 563 | ||
| 564 | ```swift | |
| 565 | import Foundation | |
| 566 | import Testing | |
| 567 | ||
| 568 | @testable import KeycaskCore | |
| 569 | ||
| 570 | @Suite struct EntryTests { | |
| 571 | @Test func initNormalizesTagsAndTruncatesDates() { | |
| 572 | let now = Date(timeIntervalSince1970: 1_700_000_000.75) | |
| 573 | let e = Entry(name: "gh", password: "p", tags: [" work", "Dev", "dev", "", "alpha"], now: now) | |
| 574 | #expect(e.tags == ["alpha", "Dev", "work"]) | |
| 575 | #expect(e.created == Date(timeIntervalSince1970: 1_700_000_000)) | |
| 576 | #expect(e.updated == e.created) | |
| 577 | } | |
| 578 | ||
| 579 | @Test func normalizeSortsCaseInsensitivelyAndKeepsFirstSpelling() { | |
| 580 | #expect(Entry.normalize(tags: ["b", "A", "a", "B"]) == ["A", "b"]) | |
| 581 | #expect(Entry.normalize(tags: []) == []) | |
| 582 | } | |
| 583 | ||
| 584 | @Test func hasTagIsCaseInsensitive() { | |
| 585 | let e = Entry(name: "gh", password: "p", tags: ["Dev"]) | |
| 586 | #expect(e.hasTag("dev")) | |
| 587 | #expect(e.hasTag("DEV")) | |
| 588 | #expect(!e.hasTag("ops")) | |
| 589 | } | |
| 590 | ||
| 591 | @Test func matchesSearchesEveryTextFieldExceptPassword() { | |
| 592 | let e = Entry( | |
| 593 | name: "GitHub", username: "cmc", password: "hunter2", url: "https://github.com", | |
| 594 | notes: "downtown office", tags: ["Dev"]) | |
| 595 | #expect(e.matches("github")) | |
| 596 | #expect(e.matches("CMC")) | |
| 597 | #expect(e.matches("github.com")) | |
| 598 | #expect(e.matches("downtown")) | |
| 599 | #expect(e.matches("dev")) | |
| 600 | #expect(!e.matches("hunter2")) | |
| 601 | #expect(!e.matches("nothing")) | |
| 602 | } | |
| 603 | } | |
| 604 | ``` | |
| 605 | ||
| 606 | - [ ] **Step 2: Run test to verify it fails** | |
| 607 | ||
| 608 | Run: `swift test --filter EntryTests` | |
| 609 | Expected: compile error, `Entry` not found. | |
| 610 | ||
| 611 | - [ ] **Step 3: Write the implementation** | |
| 612 | ||
| 613 | `Sources/KeycaskCore/Entry.swift`: | |
| 614 | ||
| 615 | ```swift | |
| 616 | import Foundation | |
| 617 | ||
| 618 | public struct Entry: Codable, Equatable, Sendable { | |
| 619 | public let id: EntryID | |
| 620 | public var name: String | |
| 621 | public var username: String? | |
| 622 | public var password: String | |
| 623 | public var url: String? | |
| 624 | public var notes: String? | |
| 625 | public var tags: [String] | |
| 626 | public let created: Date | |
| 627 | public var updated: Date | |
| 628 | ||
| 629 | public init( | |
| 630 | id: EntryID = .random(), | |
| 631 | name: String, | |
| 632 | username: String? = nil, | |
| 633 | password: String, | |
| 634 | url: String? = nil, | |
| 635 | notes: String? = nil, | |
| 636 | tags: [String] = [], | |
| 637 | now: Date = .now | |
| 638 | ) { | |
| 639 | self.id = id | |
| 640 | self.name = name | |
| 641 | self.username = username | |
| 642 | self.password = password | |
| 643 | self.url = url | |
| 644 | self.notes = notes | |
| 645 | self.tags = Self.normalize(tags: tags) | |
| 646 | let stamp = Self.truncateToSeconds(now) | |
| 647 | created = stamp | |
| 648 | updated = stamp | |
| 649 | } | |
| 650 | ||
| 651 | public static func normalize(tags: [String]) -> [String] { | |
| 652 | var seen: Set<String> = [] | |
| 653 | var out: [String] = [] | |
| 654 | for raw in tags { | |
| 655 | let tag = raw.trimmingCharacters(in: .whitespaces) | |
| 656 | guard !tag.isEmpty, seen.insert(tag.lowercased()).inserted else { continue } | |
| 657 | out.append(tag) | |
| 658 | } | |
| 659 | return out.sorted { a, b in | |
| 660 | let (la, lb) = (a.lowercased(), b.lowercased()) | |
| 661 | return la == lb ? a < b : la < lb | |
| 662 | } | |
| 663 | } | |
| 664 | ||
| 665 | public static func truncateToSeconds(_ date: Date) -> Date { | |
| 666 | Date(timeIntervalSince1970: date.timeIntervalSince1970.rounded(.down)) | |
| 667 | } | |
| 668 | ||
| 669 | public func hasTag(_ tag: String) -> Bool { | |
| 670 | let needle = tag.lowercased() | |
| 671 | return tags.contains { $0.lowercased() == needle } | |
| 672 | } | |
| 673 | ||
| 674 | public func matches(_ query: String) -> Bool { | |
| 675 | let needle = query.lowercased() | |
| 676 | guard !needle.isEmpty else { return false } | |
| 677 | let haystacks = [name, username ?? "", url ?? "", notes ?? ""] + tags | |
| 678 | return haystacks.contains { $0.lowercased().contains(needle) } | |
| 679 | } | |
| 680 | } | |
| 681 | ``` | |
| 682 | ||
| 683 | - [ ] **Step 4: Switch `ambiguous` to carry entries** | |
| 684 | ||
| 685 | In `KeycaskError.swift` change the case to `case ambiguous(name: String, candidates: [Entry])` and the message body to: | |
| 686 | ||
| 687 | ```swift | |
| 688 | case .ambiguous(let name, let candidates): | |
| 689 | (["\(name): ambiguous, use an id:"] | |
| 690 | + candidates.map { " \($0.id.rawValue) \($0.username ?? "") \($0.url ?? "")" }) | |
| 691 | .joined(separator: "\n") | |
| 692 | ``` | |
| 693 | ||
| 694 | `KeycaskErrorTests.swift` already passes `candidates: []`, which now infers `[Entry]`. Add one test there: | |
| 695 | ||
| 696 | ```swift | |
| 697 | @Test func ambiguousListsCandidateIDs() { | |
| 698 | let a = Entry(id: EntryID("aaaa2222")!, name: "gh", username: "one", password: "p") | |
| 699 | let b = Entry(id: EntryID("bbbb3333")!, name: "gh", password: "p", url: "https://x") | |
| 700 | let m = KeycaskError.ambiguous(name: "gh", candidates: [a, b]).message | |
| 701 | #expect(m.hasPrefix("gh: ambiguous, use an id:\n")) | |
| 702 | #expect(m.contains("aaaa2222")) | |
| 703 | #expect(m.contains("bbbb3333")) | |
| 704 | #expect(m.contains("https://x")) | |
| 705 | } | |
| 706 | ``` | |
| 707 | ||
| 708 | - [ ] **Step 5: Run tests** | |
| 709 | ||
| 710 | Run: `swift test --filter 'EntryTests|KeycaskErrorTests'` | |
| 711 | Expected: all pass. | |
| 712 | ||
| 713 | - [ ] **Step 6: Commit** | |
| 714 | ||
| 715 | ```bash | |
| 716 | git add Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 717 | git commit -m "Add Entry with tag normalization and search" | |
| 718 | ``` | |
| 719 | ||
| 720 | --- | |
| 721 | ||
| 722 | ### Task 5: Vault and VaultCodec | |
| 723 | ||
| 724 | **Files:** | |
| 725 | - Create: `Sources/KeycaskCore/Vault.swift` | |
| 726 | - Create: `Sources/KeycaskCore/VaultCodec.swift` | |
| 727 | - Create: `Tests/KeycaskCoreTests/VaultTests.swift` | |
| 728 | - Create: `Tests/KeycaskCoreTests/VaultCodecTests.swift` | |
| 729 | ||
| 730 | **Interfaces:** | |
| 731 | - Consumes: `Entry`, `EntryID`, `KeycaskError`. | |
| 732 | - Produces: | |
| 733 | ||
| 734 | ```swift | |
| 735 | public struct Vault: Codable, Equatable, Sendable { | |
| 736 | public var entries: [Entry] | |
| 737 | public init(entries: [Entry] = []) | |
| 738 | public func entry(id: EntryID) -> Entry? | |
| 739 | public mutating func add(_ entry: Entry) throws // duplicateID | |
| 740 | public mutating func remove(id: EntryID) throws // notFound(id) | |
| 741 | public mutating func update(id: EntryID, now: Date = .now, | |
| 742 | _ change: (inout Entry) -> Void) throws // notFound(id); normalizes tags, sets updated | |
| 743 | public func resolve(_ ref: String) throws -> Entry // id, unique name, ambiguous, notFound | |
| 744 | public func filter(tag: String) -> [Entry] | |
| 745 | public func search(_ query: String) -> [Entry] | |
| 746 | public var sortedEntries: [Entry] // by name (case-insensitive), then id | |
| 747 | } | |
| 748 | ||
| 749 | public enum VaultCodec { | |
| 750 | public static func encode(_ vault: Vault) throws -> Data // sortedKeys, iso8601; io on failure | |
| 751 | public static func decode(_ data: Data) throws -> Vault // corrupt on failure | |
| 752 | public static func makeEncoder() -> JSONEncoder // shared settings, also used by CLI output | |
| 753 | } | |
| 754 | ``` | |
| 755 | ||
| 756 | - [ ] **Step 1: Write the failing tests** | |
| 757 | ||
| 758 | `Tests/KeycaskCoreTests/VaultTests.swift`: | |
| 759 | ||
| 760 | ```swift | |
| 761 | import Foundation | |
| 762 | import Testing | |
| 763 | ||
| 764 | @testable import KeycaskCore | |
| 765 | ||
| 766 | @Suite struct VaultTests { | |
| 767 | func idA() -> EntryID { EntryID("aaaa2222")! } | |
| 768 | func idB() -> EntryID { EntryID("bbbb3333")! } | |
| 769 | ||
| 770 | @Test func addRejectsDuplicateID() throws { | |
| 771 | var v = Vault() | |
| 772 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 773 | #expect(throws: KeycaskError.duplicateID(idA())) { | |
| 774 | try v.add(Entry(id: idA(), name: "other", password: "p")) | |
| 775 | } | |
| 776 | #expect(v.entries.count == 1) | |
| 777 | } | |
| 778 | ||
| 779 | @Test func removeUnknownIsNotFound() { | |
| 780 | var v = Vault() | |
| 781 | #expect(throws: KeycaskError.notFound("aaaa2222")) { try v.remove(id: idA()) } | |
| 782 | } | |
| 783 | ||
| 784 | @Test func updateSetsUpdatedAndNormalizesTags() throws { | |
| 785 | let t0 = Date(timeIntervalSince1970: 1_000) | |
| 786 | let t1 = Date(timeIntervalSince1970: 2_000.9) | |
| 787 | var v = Vault() | |
| 788 | try v.add(Entry(id: idA(), name: "gh", password: "p", now: t0)) | |
| 789 | try v.update(id: idA(), now: t1) { e in | |
| 790 | e.tags = ["z", "A", "a"] | |
| 791 | e.password = "q" | |
| 792 | } | |
| 793 | let e = v.entry(id: idA())! | |
| 794 | #expect(e.password == "q") | |
| 795 | #expect(e.tags == ["A", "z"]) | |
| 796 | #expect(e.created == t0) | |
| 797 | #expect(e.updated == Date(timeIntervalSince1970: 2_000)) | |
| 798 | } | |
| 799 | ||
| 800 | @Test func resolvePrefersIDThenUniqueName() throws { | |
| 801 | var v = Vault() | |
| 802 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 803 | try v.add(Entry(id: idB(), name: "aaaa2222", password: "p")) | |
| 804 | #expect(try v.resolve("aaaa2222").id == idA()) | |
| 805 | #expect(try v.resolve("gh").id == idA()) | |
| 806 | #expect(try v.resolve("bbbb3333").id == idB()) | |
| 807 | } | |
| 808 | ||
| 809 | @Test func resolveReportsAmbiguousWithAllCandidates() throws { | |
| 810 | var v = Vault() | |
| 811 | let a = Entry(id: idA(), name: "gh", password: "p") | |
| 812 | let b = Entry(id: idB(), name: "gh", password: "p") | |
| 813 | try v.add(a) | |
| 814 | try v.add(b) | |
| 815 | #expect(throws: KeycaskError.ambiguous(name: "gh", candidates: [a, b])) { | |
| 816 | try v.resolve("gh") | |
| 817 | } | |
| 818 | } | |
| 819 | ||
| 820 | @Test func resolveUnknownIsNotFound() { | |
| 821 | #expect(throws: KeycaskError.notFound("nope")) { try Vault().resolve("nope") } | |
| 822 | } | |
| 823 | ||
| 824 | @Test func filterAndSearch() throws { | |
| 825 | var v = Vault() | |
| 826 | try v.add(Entry(id: idA(), name: "GitHub", password: "p", tags: ["dev"])) | |
| 827 | try v.add(Entry(id: idB(), name: "bank", password: "p", url: "https://bank.example")) | |
| 828 | #expect(v.filter(tag: "DEV").map(\.id) == [idA()]) | |
| 829 | #expect(v.search("example").map(\.id) == [idB()]) | |
| 830 | #expect(v.search("zzz").isEmpty) | |
| 831 | } | |
| 832 | ||
| 833 | @Test func sortedEntriesOrderByNameThenID() throws { | |
| 834 | var v = Vault() | |
| 835 | try v.add(Entry(id: idB(), name: "gh", password: "p")) | |
| 836 | try v.add(Entry(id: idA(), name: "gh", password: "p")) | |
| 837 | try v.add(Entry(id: EntryID("cccc4444")!, name: "Alpha", password: "p")) | |
| 838 | #expect(v.sortedEntries.map(\.id.rawValue) == ["cccc4444", "aaaa2222", "bbbb3333"]) | |
| 839 | } | |
| 840 | } | |
| 841 | ``` | |
| 842 | ||
| 843 | `Tests/KeycaskCoreTests/VaultCodecTests.swift`: | |
| 844 | ||
| 845 | ```swift | |
| 846 | import Foundation | |
| 847 | import Testing | |
| 848 | ||
| 849 | @testable import KeycaskCore | |
| 850 | ||
| 851 | @Suite struct VaultCodecTests { | |
| 852 | @Test func roundTripsAndIsDeterministic() throws { | |
| 853 | var v = Vault() | |
| 854 | try v.add( | |
| 855 | Entry( | |
| 856 | id: EntryID("aaaa2222")!, name: "gh", username: "cmc", password: "p", | |
| 857 | url: "https://github.com", notes: "n", tags: ["dev"], | |
| 858 | now: Date(timeIntervalSince1970: 1_700_000_000))) | |
| 859 | let a = try VaultCodec.encode(v) | |
| 860 | let b = try VaultCodec.encode(v) | |
| 861 | #expect(a == b) | |
| 862 | #expect(try VaultCodec.decode(a) == v) | |
| 863 | } | |
| 864 | ||
| 865 | @Test func datesAreISO8601WholeSeconds() throws { | |
| 866 | var v = Vault() | |
| 867 | try v.add( | |
| 868 | Entry(id: EntryID("aaaa2222")!, name: "gh", password: "p", | |
| 869 | now: Date(timeIntervalSince1970: 1_700_000_000))) | |
| 870 | let text = String(decoding: try VaultCodec.encode(v), as: UTF8.self) | |
| 871 | #expect(text.contains("\"created\":\"2023-11-14T22:13:20Z\"")) | |
| 872 | } | |
| 873 | ||
| 874 | @Test func keysAreSorted() throws { | |
| 875 | var v = Vault() | |
| 876 | try v.add(Entry(id: EntryID("aaaa2222")!, name: "gh", password: "p")) | |
| 877 | let text = String(decoding: try VaultCodec.encode(v), as: UTF8.self) | |
| 878 | let created = text.range(of: "\"created\"")!.lowerBound | |
| 879 | let id = text.range(of: "\"id\"")!.lowerBound | |
| 880 | let updated = text.range(of: "\"updated\"")!.lowerBound | |
| 881 | #expect(created < id && id < updated) | |
| 882 | } | |
| 883 | ||
| 884 | @Test func garbageIsCorrupt() { | |
| 885 | #expect(throws: KeycaskError.self) { try VaultCodec.decode(Data("nope".utf8)) } | |
| 886 | do { | |
| 887 | _ = try VaultCodec.decode(Data("{\"entries\":[{\"id\":1}]}".utf8)) | |
| 888 | Issue.record("expected corrupt") | |
| 889 | } catch let e as KeycaskError { | |
| 890 | #expect(e.exitCode == 1) | |
| 891 | #expect(e.message.hasPrefix("vault is corrupt:")) | |
| 892 | } catch { | |
| 893 | Issue.record("wrong error \(error)") | |
| 894 | } | |
| 895 | } | |
| 896 | } | |
| 897 | ``` | |
| 898 | ||
| 899 | - [ ] **Step 2: Run tests to verify they fail** | |
| 900 | ||
| 901 | Run: `swift test --filter 'VaultTests|VaultCodecTests'` | |
| 902 | Expected: compile error, `Vault` not found. | |
| 903 | ||
| 904 | - [ ] **Step 3: Write Vault.swift** | |
| 905 | ||
| 906 | ```swift | |
| 907 | import Foundation | |
| 908 | ||
| 909 | public struct Vault: Codable, Equatable, Sendable { | |
| 910 | public var entries: [Entry] | |
| 911 | ||
| 912 | public init(entries: [Entry] = []) { | |
| 913 | self.entries = entries | |
| 914 | } | |
| 915 | ||
| 916 | public func entry(id: EntryID) -> Entry? { | |
| 917 | entries.first { $0.id == id } | |
| 918 | } | |
| 919 | ||
| 920 | public mutating func add(_ entry: Entry) throws { | |
| 921 | guard self.entry(id: entry.id) == nil else { throw KeycaskError.duplicateID(entry.id) } | |
| 922 | entries.append(entry) | |
| 923 | } | |
| 924 | ||
| 925 | public mutating func remove(id: EntryID) throws { | |
| 926 | guard let index = entries.firstIndex(where: { $0.id == id }) else { | |
| 927 | throw KeycaskError.notFound(id.rawValue) | |
| 928 | } | |
| 929 | entries.remove(at: index) | |
| 930 | } | |
| 931 | ||
| 932 | public mutating func update( | |
| 933 | id: EntryID, now: Date = .now, _ change: (inout Entry) -> Void | |
| 934 | ) throws { | |
| 935 | guard let index = entries.firstIndex(where: { $0.id == id }) else { | |
| 936 | throw KeycaskError.notFound(id.rawValue) | |
| 937 | } | |
| 938 | change(&entries[index]) | |
| 939 | entries[index].tags = Entry.normalize(tags: entries[index].tags) | |
| 940 | entries[index].updated = Entry.truncateToSeconds(now) | |
| 941 | } | |
| 942 | ||
| 943 | public func resolve(_ ref: String) throws -> Entry { | |
| 944 | if let id = EntryID(ref), let hit = entry(id: id) { | |
| 945 | return hit | |
| 946 | } | |
| 947 | let byName = entries.filter { $0.name == ref } | |
| 948 | switch byName.count { | |
| 949 | case 0: throw KeycaskError.notFound(ref) | |
| 950 | case 1: return byName[0] | |
| 951 | default: throw KeycaskError.ambiguous(name: ref, candidates: byName) | |
| 952 | } | |
| 953 | } | |
| 954 | ||
| 955 | public func filter(tag: String) -> [Entry] { | |
| 956 | sortedEntries.filter { $0.hasTag(tag) } | |
| 957 | } | |
| 958 | ||
| 959 | public func search(_ query: String) -> [Entry] { | |
| 960 | sortedEntries.filter { $0.matches(query) } | |
| 961 | } | |
| 962 | ||
| 963 | public var sortedEntries: [Entry] { | |
| 964 | entries.sorted { a, b in | |
| 965 | let (la, lb) = (a.name.lowercased(), b.name.lowercased()) | |
| 966 | return la == lb ? a.id.rawValue < b.id.rawValue : la < lb | |
| 967 | } | |
| 968 | } | |
| 969 | } | |
| 970 | ``` | |
| 971 | ||
| 972 | - [ ] **Step 4: Write VaultCodec.swift** | |
| 973 | ||
| 974 | ```swift | |
| 975 | import Foundation | |
| 976 | ||
| 977 | public enum VaultCodec { | |
| 978 | public static func makeEncoder() -> JSONEncoder { | |
| 979 | let encoder = JSONEncoder() | |
| 980 | encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes] | |
| 981 | encoder.dateEncodingStrategy = .iso8601 | |
| 982 | return encoder | |
| 983 | } | |
| 984 | ||
| 985 | public static func makeDecoder() -> JSONDecoder { | |
| 986 | let decoder = JSONDecoder() | |
| 987 | decoder.dateDecodingStrategy = .iso8601 | |
| 988 | return decoder | |
| 989 | } | |
| 990 | ||
| 991 | public static func encode(_ vault: Vault) throws -> Data { | |
| 992 | do { | |
| 993 | return try makeEncoder().encode(vault) | |
| 994 | } catch { | |
| 995 | throw KeycaskError.io("encode vault: \(error)") | |
| 996 | } | |
| 997 | } | |
| 998 | ||
| 999 | public static func decode(_ data: Data) throws -> Vault { | |
| 1000 | do { | |
| 1001 | return try makeDecoder().decode(Vault.self, from: data) | |
| 1002 | } catch { | |
| 1003 | throw KeycaskError.corrupt("\(error)") | |
| 1004 | } | |
| 1005 | } | |
| 1006 | } | |
| 1007 | ``` | |
| 1008 | ||
| 1009 | - [ ] **Step 5: Run tests** | |
| 1010 | ||
| 1011 | Run: `swift test --filter 'VaultTests|VaultCodecTests'` | |
| 1012 | Expected: 12 tests pass. | |
| 1013 | ||
| 1014 | - [ ] **Step 6: Commit** | |
| 1015 | ||
| 1016 | ```bash | |
| 1017 | git add Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 1018 | git commit -m "Add Vault operations and deterministic JSON codec" | |
| 1019 | ``` | |
| 1020 | ||
| 1021 | --- | |
| 1022 | ||
| 1023 | ### Task 6: Generator and word list | |
| 1024 | ||
| 1025 | **Files:** | |
| 1026 | - Create: `Sources/KeycaskCore/Wordlist.swift` (generated) | |
| 1027 | - Create: `Sources/KeycaskCore/Generator.swift` | |
| 1028 | - Create: `NOTICE` | |
| 1029 | - Create: `Tests/KeycaskCoreTests/GeneratorTests.swift` | |
| 1030 | ||
| 1031 | **Interfaces:** | |
| 1032 | - Produces: | |
| 1033 | ||
| 1034 | ```swift | |
| 1035 | public enum Wordlist { public static let words: [String] } // 7776 entries | |
| 1036 | public enum Generator { | |
| 1037 | public static let alphabet: [Character] // A-Z a-z 0-9 and !@#$%^&*()-_=+[]{};:,.<>? | |
| 1038 | public static let defaultLength = 24 | |
| 1039 | public static let wordSeparator = "-" | |
| 1040 | public static func password(length: Int) -> String | |
| 1041 | public static func password(length: Int, using: inout some RandomNumberGenerator) -> String | |
| 1042 | public static func passphrase(words: Int) -> String | |
| 1043 | public static func passphrase(words: Int, using: inout some RandomNumberGenerator) -> String | |
| 1044 | } | |
| 1045 | ``` | |
| 1046 | ||
| 1047 | - [ ] **Step 1: Generate Wordlist.swift from the EFF list** | |
| 1048 | ||
| 1049 | ```bash | |
| 1050 | cd /Users/cmc/git/krz/keycask | |
| 1051 | curl -fsSL https://www.eff.org/files/2016/07/18/eff_large_wordlist.txt -o /tmp/eff.txt | |
| 1052 | test "$(wc -l < /tmp/eff.txt)" -eq 7776 | |
| 1053 | { | |
| 1054 | printf '// EFF long word list, https://www.eff.org/dice. See NOTICE.\n' | |
| 1055 | printf 'let effLongWordlist = """\n' | |
| 1056 | cut -f2 /tmp/eff.txt | |
| 1057 | printf '"""\n\npublic enum Wordlist {\n' | |
| 1058 | printf ' public static let words: [String] = effLongWordlist.split(separator: "\\n").map(String.init)\n' | |
| 1059 | printf '}\n' | |
| 1060 | } > Sources/KeycaskCore/Wordlist.swift | |
| 1061 | rm /tmp/eff.txt | |
| 1062 | ``` | |
| 1063 | ||
| 1064 | - [ ] **Step 2: Write NOTICE** | |
| 1065 | ||
| 1066 | ``` | |
| 1067 | The word list in Sources/KeycaskCore/Wordlist.swift is the EFF Long | |
| 1068 | Wordlist by the Electronic Frontier Foundation, licensed under the | |
| 1069 | Creative Commons Attribution 3.0 United States License. | |
| 1070 | https://www.eff.org/dice | |
| 1071 | https://creativecommons.org/licenses/by/3.0/us/ | |
| 1072 | ``` | |
| 1073 | ||
| 1074 | - [ ] **Step 3: Write the failing test** | |
| 1075 | ||
| 1076 | `Tests/KeycaskCoreTests/GeneratorTests.swift`: | |
| 1077 | ||
| 1078 | ```swift | |
| 1079 | import Testing | |
| 1080 | ||
| 1081 | @testable import KeycaskCore | |
| 1082 | ||
| 1083 | @Suite struct GeneratorTests { | |
| 1084 | struct Counter: RandomNumberGenerator { | |
| 1085 | var n: UInt64 = 0 | |
| 1086 | mutating func next() -> UInt64 { | |
| 1087 | n &+= 0x9E37_79B9_7F4A_7C15 | |
| 1088 | return n | |
| 1089 | } | |
| 1090 | } | |
| 1091 | ||
| 1092 | @Test func wordlistHas7776UniqueWords() { | |
| 1093 | #expect(Wordlist.words.count == 7776) | |
| 1094 | #expect(Set(Wordlist.words).count == 7776) | |
| 1095 | #expect(Wordlist.words.first == "abacus") | |
| 1096 | #expect(Wordlist.words.allSatisfy { !$0.isEmpty && !$0.contains(" ") }) | |
| 1097 | } | |
| 1098 | ||
| 1099 | @Test func passwordHasRequestedLengthFromTheAlphabet() { | |
| 1100 | let allowed = Set(Generator.alphabet) | |
| 1101 | for length in [1, 8, 24, 64] { | |
| 1102 | let p = Generator.password(length: length) | |
| 1103 | #expect(p.count == length) | |
| 1104 | #expect(p.allSatisfy { allowed.contains($0) }) | |
| 1105 | } | |
| 1106 | #expect(Generator.password(length: 0) == "") | |
| 1107 | } | |
| 1108 | ||
| 1109 | @Test func alphabetCoversAllClasses() { | |
| 1110 | let s = String(Generator.alphabet) | |
| 1111 | #expect(s.contains("A") && s.contains("z") && s.contains("7") && s.contains("!")) | |
| 1112 | #expect(Set(Generator.alphabet).count == Generator.alphabet.count) | |
| 1113 | } | |
| 1114 | ||
| 1115 | @Test func passphraseUsesWordsFromTheList() { | |
| 1116 | let words = Set(Wordlist.words) | |
| 1117 | let p = Generator.passphrase(words: 5) | |
| 1118 | let parts = p.split(separator: "-").map(String.init) | |
| 1119 | #expect(parts.count == 5) | |
| 1120 | #expect(parts.allSatisfy { words.contains($0) }) | |
| 1121 | #expect(Generator.passphrase(words: 0) == "") | |
| 1122 | } | |
| 1123 | ||
| 1124 | @Test func seededOutputIsReproducible() { | |
| 1125 | var a = Counter() | |
| 1126 | var b = Counter() | |
| 1127 | #expect(Generator.password(length: 16, using: &a) == Generator.password(length: 16, using: &b)) | |
| 1128 | #expect(Generator.passphrase(words: 3, using: &a) == Generator.passphrase(words: 3, using: &b)) | |
| 1129 | } | |
| 1130 | } | |
| 1131 | ``` | |
| 1132 | ||
| 1133 | - [ ] **Step 4: Run test to verify it fails** | |
| 1134 | ||
| 1135 | Run: `swift test --filter GeneratorTests` | |
| 1136 | Expected: compile error, `Generator` not found. | |
| 1137 | ||
| 1138 | - [ ] **Step 5: Write Generator.swift** | |
| 1139 | ||
| 1140 | ```swift | |
| 1141 | public enum Generator { | |
| 1142 | public static let alphabet: [Character] = Array( | |
| 1143 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+[]{};:,.<>?" | |
| 1144 | ) | |
| 1145 | public static let defaultLength = 24 | |
| 1146 | public static let wordSeparator = "-" | |
| 1147 | ||
| 1148 | public static func password(length: Int) -> String { | |
| 1149 | var rng = SystemRandomNumberGenerator() | |
| 1150 | return password(length: length, using: &rng) | |
| 1151 | } | |
| 1152 | ||
| 1153 | public static func password(length: Int, using rng: inout some RandomNumberGenerator) -> String { | |
| 1154 | var chars: [Character] = [] | |
| 1155 | chars.reserveCapacity(max(length, 0)) | |
| 1156 | for _ in 0..<max(length, 0) { | |
| 1157 | chars.append(alphabet[Int(rng.next(upperBound: UInt32(alphabet.count)))]) | |
| 1158 | } | |
| 1159 | return String(chars) | |
| 1160 | } | |
| 1161 | ||
| 1162 | public static func passphrase(words: Int) -> String { | |
| 1163 | var rng = SystemRandomNumberGenerator() | |
| 1164 | return passphrase(words: words, using: &rng) | |
| 1165 | } | |
| 1166 | ||
| 1167 | public static func passphrase(words: Int, using rng: inout some RandomNumberGenerator) -> String { | |
| 1168 | let list = Wordlist.words | |
| 1169 | var picked: [String] = [] | |
| 1170 | for _ in 0..<max(words, 0) { | |
| 1171 | picked.append(list[Int(rng.next(upperBound: UInt32(list.count)))]) | |
| 1172 | } | |
| 1173 | return picked.joined(separator: wordSeparator) | |
| 1174 | } | |
| 1175 | } | |
| 1176 | ``` | |
| 1177 | ||
| 1178 | - [ ] **Step 6: Run tests and lint** | |
| 1179 | ||
| 1180 | Run: `swift test --filter GeneratorTests && swift format lint --strict --recursive Sources Tests` | |
| 1181 | Expected: 5 tests pass. If the linter complains about the long string literal in `Wordlist.swift`, add `"// swift-format-ignore-file"` as its first line. | |
| 1182 | ||
| 1183 | - [ ] **Step 7: Commit** | |
| 1184 | ||
| 1185 | ```bash | |
| 1186 | git add NOTICE Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 1187 | git commit -m "Add password and passphrase generator with EFF word list" | |
| 1188 | ``` | |
| 1189 | ||
| 1190 | --- | |
| 1191 | ||
| 1192 | ### Task 7: Envelope | |
| 1193 | ||
| 1194 | **Files:** | |
| 1195 | - Create: `Sources/KeycaskCore/Envelope.swift` | |
| 1196 | - Create: `Tests/KeycaskCoreTests/EnvelopeTests.swift` | |
| 1197 | ||
| 1198 | **Interfaces:** | |
| 1199 | - Consumes: `KeycaskError`. | |
| 1200 | - Produces: | |
| 1201 | ||
| 1202 | ```swift | |
| 1203 | public struct Envelope: Codable, Equatable, Sendable { | |
| 1204 | public struct KDFParams: Codable, Equatable, Sendable { | |
| 1205 | public var name: String | |
| 1206 | public var iterations: Int | |
| 1207 | public var salt: Data | |
| 1208 | public init(name: String, iterations: Int, salt: Data) | |
| 1209 | public static func fresh(iterations: Int = Envelope.defaultIterations) -> KDFParams | |
| 1210 | } | |
| 1211 | public static let currentFormat = 1 | |
| 1212 | public static let defaultIterations = 600_000 | |
| 1213 | public static let kdfName = "pbkdf2-hmac-sha256" | |
| 1214 | public static let saltLength = 16 | |
| 1215 | public var format: Int | |
| 1216 | public var kdf: KDFParams | |
| 1217 | public var box: Data | |
| 1218 | ||
| 1219 | public static func seal(_ plaintext: Data, passphrase: String, kdf: KDFParams) throws -> Envelope | |
| 1220 | public func open(passphrase: String) throws -> Data // cannotDecrypt / corrupt | |
| 1221 | public init(parsing data: Data) throws // corrupt | |
| 1222 | public func encoded() throws -> Data | |
| 1223 | static func deriveKey(passphrase: String, kdf: KDFParams) throws -> SymmetricKey | |
| 1224 | } | |
| 1225 | ``` | |
| 1226 | ||
| 1227 | - [ ] **Step 1: Write the failing test** | |
| 1228 | ||
| 1229 | `Tests/KeycaskCoreTests/EnvelopeTests.swift`: | |
| 1230 | ||
| 1231 | ```swift | |
| 1232 | import Crypto | |
| 1233 | import Foundation | |
| 1234 | import Testing | |
| 1235 | ||
| 1236 | @testable import KeycaskCore | |
| 1237 | ||
| 1238 | @Suite struct EnvelopeTests { | |
| 1239 | // Low iteration count keeps the suite fast. Production uses Envelope.defaultIterations. | |
| 1240 | let kdf = Envelope.KDFParams( | |
| 1241 | name: Envelope.kdfName, iterations: 1_000, salt: Data(repeating: 7, count: 16)) | |
| 1242 | ||
| 1243 | func hex(_ key: SymmetricKey) -> String { | |
| 1244 | key.withUnsafeBytes { $0.map { String(format: "%02x", $0) }.joined() } | |
| 1245 | } | |
| 1246 | ||
| 1247 | @Test func pbkdf2MatchesPublishedVectors() throws { | |
| 1248 | let one = Envelope.KDFParams(name: Envelope.kdfName, iterations: 1, salt: Data("salt".utf8)) | |
| 1249 | #expect( | |
| 1250 | hex(try Envelope.deriveKey(passphrase: "password", kdf: one)) | |
| 1251 | == "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b") | |
| 1252 | let many = Envelope.KDFParams(name: Envelope.kdfName, iterations: 4096, salt: Data("salt".utf8)) | |
| 1253 | #expect( | |
| 1254 | hex(try Envelope.deriveKey(passphrase: "password", kdf: many)) | |
| 1255 | == "c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a") | |
| 1256 | } | |
| 1257 | ||
| 1258 | @Test func sealThenOpenRoundTrips() throws { | |
| 1259 | let env = try Envelope.seal(Data("hello vault".utf8), passphrase: "pw", kdf: kdf) | |
| 1260 | #expect(env.format == 1) | |
| 1261 | #expect(env.kdf == kdf) | |
| 1262 | #expect(try env.open(passphrase: "pw") == Data("hello vault".utf8)) | |
| 1263 | } | |
| 1264 | ||
| 1265 | @Test func wrongPassphraseCannotDecrypt() throws { | |
| 1266 | let env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1267 | #expect(throws: KeycaskError.cannotDecrypt) { try env.open(passphrase: "PW") } | |
| 1268 | } | |
| 1269 | ||
| 1270 | @Test func tamperedBoxCannotDecrypt() throws { | |
| 1271 | var env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1272 | env.box[env.box.count - 1] ^= 0x01 | |
| 1273 | #expect(throws: KeycaskError.cannotDecrypt) { try env.open(passphrase: "pw") } | |
| 1274 | } | |
| 1275 | ||
| 1276 | @Test func nonceIsFreshAndSaltIsKept() throws { | |
| 1277 | let a = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1278 | let b = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1279 | #expect(a.box != b.box) | |
| 1280 | #expect(a.kdf.salt == b.kdf.salt) | |
| 1281 | } | |
| 1282 | ||
| 1283 | @Test func freshParamsUseDefaults() { | |
| 1284 | let p = Envelope.KDFParams.fresh() | |
| 1285 | #expect(p.name == "pbkdf2-hmac-sha256") | |
| 1286 | #expect(p.iterations == 600_000) | |
| 1287 | #expect(p.salt.count == 16) | |
| 1288 | #expect(p.salt != Envelope.KDFParams.fresh().salt) | |
| 1289 | } | |
| 1290 | ||
| 1291 | @Test func encodedShapeMatchesTheSpec() throws { | |
| 1292 | let env = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1293 | let json = try JSONSerialization.jsonObject(with: env.encoded()) as! [String: Any] | |
| 1294 | #expect(json["format"] as? Int == 1) | |
| 1295 | let k = json["kdf"] as! [String: Any] | |
| 1296 | #expect(k["name"] as? String == "pbkdf2-hmac-sha256") | |
| 1297 | #expect(k["iterations"] as? Int == 1_000) | |
| 1298 | #expect(Data(base64Encoded: k["salt"] as! String) == kdf.salt) | |
| 1299 | #expect(Data(base64Encoded: json["box"] as! String) == env.box) | |
| 1300 | #expect(try Envelope(parsing: env.encoded()) == env) | |
| 1301 | } | |
| 1302 | ||
| 1303 | @Test func malformedInputsAreCorrupt() throws { | |
| 1304 | #expect(throws: KeycaskError.self) { try Envelope(parsing: Data("not json".utf8)) } | |
| 1305 | #expect(throws: KeycaskError.self) { try Envelope(parsing: Data("{\"format\":1}".utf8)) } | |
| 1306 | ||
| 1307 | var wrongFormat = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1308 | wrongFormat.format = 2 | |
| 1309 | #expect(throws: KeycaskError.corrupt("unsupported format 2")) { | |
| 1310 | try wrongFormat.open(passphrase: "pw") | |
| 1311 | } | |
| 1312 | ||
| 1313 | var wrongKDF = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1314 | wrongKDF.kdf.name = "argon2id" | |
| 1315 | #expect(throws: KeycaskError.corrupt("unsupported kdf argon2id")) { | |
| 1316 | try wrongKDF.open(passphrase: "pw") | |
| 1317 | } | |
| 1318 | ||
| 1319 | var shortBox = try Envelope.seal(Data("x".utf8), passphrase: "pw", kdf: kdf) | |
| 1320 | shortBox.box = Data([1, 2, 3]) | |
| 1321 | #expect(throws: KeycaskError.corrupt("box too short")) { try shortBox.open(passphrase: "pw") } | |
| 1322 | } | |
| 1323 | ||
| 1324 | @Test func passphraseIsNFCNormalized() throws { | |
| 1325 | let composed = "caf\u{00E9}" | |
| 1326 | let decomposed = "cafe\u{0301}" | |
| 1327 | let env = try Envelope.seal(Data("x".utf8), passphrase: composed, kdf: kdf) | |
| 1328 | #expect(try env.open(passphrase: decomposed) == Data("x".utf8)) | |
| 1329 | } | |
| 1330 | } | |
| 1331 | ``` | |
| 1332 | ||
| 1333 | - [ ] **Step 2: Run test to verify it fails** | |
| 1334 | ||
| 1335 | Run: `swift test --filter EnvelopeTests` | |
| 1336 | Expected: compile error, `Envelope` not found. | |
| 1337 | ||
| 1338 | - [ ] **Step 3: Write Envelope.swift** | |
| 1339 | ||
| 1340 | ```swift | |
| 1341 | import Crypto | |
| 1342 | import Foundation | |
| 1343 | import _CryptoExtras | |
| 1344 | ||
| 1345 | public struct Envelope: Codable, Equatable, Sendable { | |
| 1346 | public struct KDFParams: Codable, Equatable, Sendable { | |
| 1347 | public var name: String | |
| 1348 | public var iterations: Int | |
| 1349 | public var salt: Data | |
| 1350 | ||
| 1351 | public init(name: String, iterations: Int, salt: Data) { | |
| 1352 | self.name = name | |
| 1353 | self.iterations = iterations | |
| 1354 | self.salt = salt | |
| 1355 | } | |
| 1356 | ||
| 1357 | public static func fresh(iterations: Int = Envelope.defaultIterations) -> KDFParams { | |
| 1358 | var rng = SystemRandomNumberGenerator() | |
| 1359 | let salt = Data((0..<Envelope.saltLength).map { _ in UInt8.random(in: .min ... .max, using: &rng) }) | |
| 1360 | return KDFParams(name: Envelope.kdfName, iterations: iterations, salt: salt) | |
| 1361 | } | |
| 1362 | } | |
| 1363 | ||
| 1364 | public static let currentFormat = 1 | |
| 1365 | public static let defaultIterations = 600_000 | |
| 1366 | public static let kdfName = "pbkdf2-hmac-sha256" | |
| 1367 | public static let saltLength = 16 | |
| 1368 | static let keyLength = 32 | |
| 1369 | static let minimumBoxLength = 12 + 16 | |
| 1370 | ||
| 1371 | public var format: Int | |
| 1372 | public var kdf: KDFParams | |
| 1373 | public var box: Data | |
| 1374 | ||
| 1375 | public static func seal(_ plaintext: Data, passphrase: String, kdf: KDFParams) throws -> Envelope { | |
| 1376 | let key = try deriveKey(passphrase: passphrase, kdf: kdf) | |
| 1377 | do { | |
| 1378 | let sealed = try ChaChaPoly.seal(plaintext, using: key) | |
| 1379 | return Envelope(format: currentFormat, kdf: kdf, box: sealed.combined) | |
| 1380 | } catch { | |
| 1381 | throw KeycaskError.failure("encrypt: \(error)") | |
| 1382 | } | |
| 1383 | } | |
| 1384 | ||
| 1385 | public func open(passphrase: String) throws -> Data { | |
| 1386 | guard format == Self.currentFormat else { | |
| 1387 | throw KeycaskError.corrupt("unsupported format \(format)") | |
| 1388 | } | |
| 1389 | guard kdf.name == Self.kdfName else { | |
| 1390 | throw KeycaskError.corrupt("unsupported kdf \(kdf.name)") | |
| 1391 | } | |
| 1392 | guard box.count >= Self.minimumBoxLength else { | |
| 1393 | throw KeycaskError.corrupt("box too short") | |
| 1394 | } | |
| 1395 | let key = try Self.deriveKey(passphrase: passphrase, kdf: kdf) | |
| 1396 | let sealed: ChaChaPoly.SealedBox | |
| 1397 | do { | |
| 1398 | sealed = try ChaChaPoly.SealedBox(combined: box) | |
| 1399 | } catch { | |
| 1400 | throw KeycaskError.corrupt("box is malformed") | |
| 1401 | } | |
| 1402 | do { | |
| 1403 | return try ChaChaPoly.open(sealed, using: key) | |
| 1404 | } catch { | |
| 1405 | throw KeycaskError.cannotDecrypt | |
| 1406 | } | |
| 1407 | } | |
| 1408 | ||
| 1409 | public init(parsing data: Data) throws { | |
| 1410 | do { | |
| 1411 | self = try JSONDecoder().decode(Envelope.self, from: data) | |
| 1412 | } catch { | |
| 1413 | throw KeycaskError.corrupt("not a keycask vault: \(error)") | |
| 1414 | } | |
| 1415 | } | |
| 1416 | ||
| 1417 | public func encoded() throws -> Data { | |
| 1418 | let encoder = JSONEncoder() | |
| 1419 | encoder.outputFormatting = [.sortedKeys, .prettyPrinted] | |
| 1420 | do { | |
| 1421 | return try encoder.encode(self) | |
| 1422 | } catch { | |
| 1423 | throw KeycaskError.io("encode envelope: \(error)") | |
| 1424 | } | |
| 1425 | } | |
| 1426 | ||
| 1427 | init(format: Int, kdf: KDFParams, box: Data) { | |
| 1428 | self.format = format | |
| 1429 | self.kdf = kdf | |
| 1430 | self.box = box | |
| 1431 | } | |
| 1432 | ||
| 1433 | static func deriveKey(passphrase: String, kdf: KDFParams) throws -> SymmetricKey { | |
| 1434 | let normalized = Array(passphrase.precomposedStringWithCanonicalMapping.utf8) | |
| 1435 | do { | |
| 1436 | return try KDF.Insecure.PBKDF2.deriveKey( | |
| 1437 | from: normalized, salt: kdf.salt, using: .sha256, | |
| 1438 | outputByteCount: keyLength, unsafeUncheckedRounds: kdf.iterations) | |
| 1439 | } catch { | |
| 1440 | throw KeycaskError.failure("derive key: \(error)") | |
| 1441 | } | |
| 1442 | } | |
| 1443 | } | |
| 1444 | ``` | |
| 1445 | ||
| 1446 | `unsafeUncheckedRounds` is used because the checked overload rejects fewer than 210000 rounds, and the vault decides the count. `KDFParams.fresh()` always produces 600000. | |
| 1447 | ||
| 1448 | - [ ] **Step 4: Run tests** | |
| 1449 | ||
| 1450 | Run: `swift test --filter EnvelopeTests` | |
| 1451 | Expected: 9 tests pass. | |
| 1452 | ||
| 1453 | - [ ] **Step 5: Commit** | |
| 1454 | ||
| 1455 | ```bash | |
| 1456 | git add Sources/KeycaskCore Tests/KeycaskCoreTests | |
| 1457 | git commit -m "Add passphrase-encrypted vault envelope" | |
| 1458 | ``` | |
| 1459 | ||
| 1460 | --- | |
| 1461 | ||
| 1462 | ### Task 8: Core merge request | |
| 1463 | ||
| 1464 | **Files:** none new. | |
| 1465 | ||
| 1466 | - [ ] **Step 1: Full suite and lint** | |
| 1467 | ||
| 1468 | Run: `swift test && swift format lint --strict --recursive Sources Tests Package.swift` | |
| 1469 | Expected: all pass, no lint output. | |
| 1470 | ||
| 1471 | - [ ] **Step 2: Push and open the MR** | |
| 1472 | ||
| 1473 | ```bash | |
| 1474 | git push -u origin core | |
| 1475 | gitbay mr create --source core --target main --title "Core library: model, envelope, generator" --file - <<'EOF' | |
| 1476 | KeycaskCore: Entry, EntryID, Vault, VaultCodec, Envelope, Generator, Wordlist, KeycaskError. | |
| 1477 | Package scaffold and gitbay CI. | |
| 1478 | EOF | |
| 1479 | ``` | |
| 1480 | ||
| 1481 | - [ ] **Step 3: Wait for CI, merge, clean up** | |
| 1482 | ||
| 1483 | Run `gitbay build list --json` until the build for `core` is green. Then: | |
| 1484 | ||
| 1485 | ```bash | |
| 1486 | gitbay mr merge <n> --strategy squash | |
| 1487 | git switch main && git pull && git branch -D core && git push origin --delete core | |
| 1488 | ``` | |
| 1489 | ||
| 1490 | If the CI job fails on the swiftly install lines, read `gitbay build log <n>`, fix `.gitbay/ci.yml` on the branch, push, and re-check. Do not merge red. | |
| 1491 | ||
| 1492 | --- | |
| 1493 | ||
| 1494 | ### Task 9: CLI skeleton, paths, passphrase, atomic write, `init` | |
| 1495 | ||
| 1496 | **Files:** | |
| 1497 | - Create: `Sources/keycask/main.swift` (replace) | |
| 1498 | - Create: `Sources/keycask/Keycask.swift` | |
| 1499 | - Create: `Sources/keycask/Paths.swift` | |
| 1500 | - Create: `Sources/keycask/Terminal.swift` | |
| 1501 | - Create: `Sources/keycask/Passphrase.swift` | |
| 1502 | - Create: `Sources/keycask/AtomicFile.swift` | |
| 1503 | - Create: `Sources/keycask/OpenVault.swift` | |
| 1504 | - Create: `Sources/keycask/Commands/Init.swift` | |
| 1505 | - Modify: `Tests/KeycaskCLITests/CLI.swift` | |
| 1506 | - Create: `Tests/KeycaskCLITests/InitTests.swift` | |
| 1507 | - Create: `Tests/KeycaskCLITests/PathsTests.swift` | |
| 1508 | ||
| 1509 | **Interfaces:** | |
| 1510 | - Consumes: `Vault`, `VaultCodec`, `Envelope`, `KeycaskError`. | |
| 1511 | - Produces: | |
| 1512 | ||
| 1513 | ```swift | |
| 1514 | struct GlobalOptions: ParsableArguments { var vault: String? } | |
| 1515 | enum Paths { static func vaultURL(override: String?, environment: [String: String]) -> URL } | |
| 1516 | enum Terminal { | |
| 1517 | static var stdinIsTTY: Bool | |
| 1518 | static func readSecretLine(prompt: String) throws -> String | |
| 1519 | static func readLine(prompt: String) -> String? | |
| 1520 | static func confirm(_ question: String) -> Bool | |
| 1521 | } | |
| 1522 | enum Passphrase { | |
| 1523 | static let variable = "KEYCASK_PASSPHRASE" | |
| 1524 | static func obtain(confirm: Bool, environment: [String: String]) throws -> String | |
| 1525 | } | |
| 1526 | enum AtomicFile { static func write(_ data: Data, to url: URL) throws } | |
| 1527 | struct OpenVault { | |
| 1528 | var vault: Vault | |
| 1529 | let kdf: Envelope.KDFParams | |
| 1530 | let url: URL | |
| 1531 | let passphrase: String | |
| 1532 | static func load(_ options: GlobalOptions) throws -> OpenVault | |
| 1533 | static func create(_ options: GlobalOptions) throws -> URL | |
| 1534 | func save() throws | |
| 1535 | } | |
| 1536 | struct CLI { // test harness | |
| 1537 | struct Result { let status: Int32; let stdout: String; let stderr: String } | |
| 1538 | let dir: URL; let vault: URL; static let passphrase = "correct horse battery" | |
| 1539 | init() throws | |
| 1540 | func run(_ args: [String], stdin: String? = nil, passphrase: String? = CLI.passphrase, | |
| 1541 | extraEnvironment: [String: String] = [:]) throws -> Result | |
| 1542 | } | |
| 1543 | ``` | |
| 1544 | ||
| 1545 | - [ ] **Step 1: Create the branch** | |
| 1546 | ||
| 1547 | ```bash | |
| 1548 | git switch -c cli | |
| 1549 | ``` | |
| 1550 | ||
| 1551 | - [ ] **Step 2: Extend the test harness** | |
| 1552 | ||
| 1553 | Replace `Tests/KeycaskCLITests/CLI.swift`: | |
| 1554 | ||
| 1555 | ```swift | |
| 1556 | import Foundation | |
| 1557 | import Testing | |
| 1558 | ||
| 1559 | enum Binary { | |
| 1560 | static let url: URL = { | |
| 1561 | #if os(macOS) | |
| 1562 | for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") { | |
| 1563 | return bundle.bundleURL.deletingLastPathComponent().appendingPathComponent("keycask") | |
| 1564 | } | |
| 1565 | fatalError("test bundle not found") | |
| 1566 | #elseif os(Windows) | |
| 1567 | return Bundle.main.bundleURL.appendingPathComponent("keycask.exe") | |
| 1568 | #else | |
| 1569 | return Bundle.main.bundleURL.appendingPathComponent("keycask") | |
| 1570 | #endif | |
| 1571 | }() | |
| 1572 | } | |
| 1573 | ||
| 1574 | struct CLI { | |
| 1575 | struct Result { | |
| 1576 | let status: Int32 | |
| 1577 | let stdout: String | |
| 1578 | let stderr: String | |
| 1579 | var lines: [String] { stdout.split(separator: "\n").map(String.init) } | |
| 1580 | } | |
| 1581 | ||
| 1582 | static let passphrase = "correct horse battery" | |
| 1583 | ||
| 1584 | let dir: URL | |
| 1585 | let vault: URL | |
| 1586 | ||
| 1587 | init() throws { | |
| 1588 | dir = FileManager.default.temporaryDirectory | |
| 1589 | .appendingPathComponent("keycask-tests-\(UUID().uuidString)") | |
| 1590 | try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true) | |
| 1591 | vault = dir.appendingPathComponent("vault.kc") | |
| 1592 | } | |
| 1593 | ||
| 1594 | @discardableResult | |
| 1595 | func run( | |
| 1596 | _ args: [String], | |
| 1597 | stdin: String? = nil, | |
| 1598 | passphrase: String? = CLI.passphrase, | |
| 1599 | extraEnvironment: [String: String] = [:] | |
| 1600 | ) throws -> Result { | |
| 1601 | let process = Process() | |
| 1602 | process.executableURL = Binary.url | |
| 1603 | process.arguments = args | |
| 1604 | var env = ProcessInfo.processInfo.environment | |
| 1605 | env["KEYCASK_VAULT"] = vault.path | |
| 1606 | env.removeValue(forKey: "KEYCASK_PASSPHRASE") | |
| 1607 | if let passphrase { env["KEYCASK_PASSPHRASE"] = passphrase } | |
| 1608 | for (k, v) in extraEnvironment { env[k] = v } | |
| 1609 | process.environment = env | |
| 1610 | ||
| 1611 | let out = Pipe() | |
| 1612 | let err = Pipe() | |
| 1613 | let input = Pipe() | |
| 1614 | process.standardOutput = out | |
| 1615 | process.standardError = err | |
| 1616 | process.standardInput = input | |
| 1617 | try process.run() | |
| 1618 | if let stdin { | |
| 1619 | input.fileHandleForWriting.write(Data(stdin.utf8)) | |
| 1620 | } | |
| 1621 | try input.fileHandleForWriting.close() | |
| 1622 | let outData = out.fileHandleForReading.readDataToEndOfFile() | |
| 1623 | let errData = err.fileHandleForReading.readDataToEndOfFile() | |
| 1624 | process.waitUntilExit() | |
| 1625 | return Result( | |
| 1626 | status: process.terminationStatus, | |
| 1627 | stdout: String(decoding: outData, as: UTF8.self), | |
| 1628 | stderr: String(decoding: errData, as: UTF8.self)) | |
| 1629 | } | |
| 1630 | ||
| 1631 | /// Runs `init` and returns the harness, for tests that need a vault. | |
| 1632 | static func initialized() throws -> CLI { | |
| 1633 | let cli = try CLI() | |
| 1634 | let r = try cli.run(["init"]) | |
| 1635 | precondition(r.status == 0, "init failed: \(r.stderr)") | |
| 1636 | return cli | |
| 1637 | } | |
| 1638 | } | |
| 1639 | ``` | |
| 1640 | ||
| 1641 | Remove the `binaryIsBuilt` test from this file; the harness replaces it. | |
| 1642 | ||
| 1643 | - [ ] **Step 3: Write the failing tests** | |
| 1644 | ||
| 1645 | `Tests/KeycaskCLITests/InitTests.swift`: | |
| 1646 | ||
| 1647 | ```swift | |
| 1648 | import Foundation | |
| 1649 | import Testing | |
| 1650 | ||
| 1651 | @Suite struct InitTests { | |
| 1652 | @Test func initCreatesVaultAndPrintsPath() throws { | |
| 1653 | let cli = try CLI() | |
| 1654 | let r = try cli.run(["init"]) | |
| 1655 | #expect(r.status == 0) | |
| 1656 | #expect(r.stdout.contains(cli.vault.path)) | |
| 1657 | #expect(FileManager.default.fileExists(atPath: cli.vault.path)) | |
| 1658 | let text = try String(contentsOf: cli.vault, encoding: .utf8) | |
| 1659 | #expect(text.contains("\"format\" : 1")) | |
| 1660 | #expect(text.contains("pbkdf2-hmac-sha256")) | |
| 1661 | #expect(!text.contains("entries")) | |
| 1662 | } | |
| 1663 | ||
| 1664 | @Test func initRefusesExistingVault() throws { | |
| 1665 | let cli = try CLI.initialized() | |
| 1666 | let r = try cli.run(["init"]) | |
| 1667 | #expect(r.status == 1) | |
| 1668 | #expect(r.stderr.contains("already exists")) | |
| 1669 | } | |
| 1670 | ||
| 1671 | @Test func initWithoutPassphraseOrTTYIsUsageError() throws { | |
| 1672 | let cli = try CLI() | |
| 1673 | let r = try cli.run(["init"], passphrase: nil) | |
| 1674 | #expect(r.status == 2) | |
| 1675 | #expect(r.stderr.contains("KEYCASK_PASSPHRASE")) | |
| 1676 | } | |
| 1677 | ||
| 1678 | @Test func emptyPassphraseIsRejected() throws { | |
| 1679 | let cli = try CLI() | |
| 1680 | let r = try cli.run(["init"], passphrase: "") | |
| 1681 | #expect(r.status == 1) | |
| 1682 | #expect(r.stderr.contains("empty")) | |
| 1683 | } | |
| 1684 | ||
| 1685 | @Test func vaultFlagBeatsEnvironment() throws { | |
| 1686 | let cli = try CLI() | |
| 1687 | let other = cli.dir.appendingPathComponent("elsewhere.kc") | |
| 1688 | let r = try cli.run(["--vault", other.path, "init"]) | |
| 1689 | #expect(r.status == 0) | |
| 1690 | #expect(FileManager.default.fileExists(atPath: other.path)) | |
| 1691 | #expect(!FileManager.default.fileExists(atPath: cli.vault.path)) | |
| 1692 | } | |
| 1693 | ||
| 1694 | @Test func unknownSubcommandIsUsageError() throws { | |
| 1695 | let cli = try CLI() | |
| 1696 | let r = try cli.run(["frobnicate"]) | |
| 1697 | #expect(r.status == 2) | |
| 1698 | #expect(r.stderr.contains("Usage")) | |
| 1699 | } | |
| 1700 | ||
| 1701 | @Test func helpExitsZero() throws { | |
| 1702 | let cli = try CLI() | |
| 1703 | let r = try cli.run(["--help"]) | |
| 1704 | #expect(r.status == 0) | |
| 1705 | #expect(r.stdout.contains("init")) | |
| 1706 | } | |
| 1707 | ||
| 1708 | #if !os(Windows) | |
| 1709 | @Test func vaultIsPrivateOnUnix() throws { | |
| 1710 | let cli = try CLI.initialized() | |
| 1711 | let attrs = try FileManager.default.attributesOfItem(atPath: cli.vault.path) | |
| 1712 | let mode = (attrs[.posixPermissions] as! NSNumber).intValue & 0o777 | |
| 1713 | #expect(mode == 0o600) | |
| 1714 | } | |
| 1715 | #endif | |
| 1716 | ||
| 1717 | @Test func noTempFileLeftBehind() throws { | |
| 1718 | let cli = try CLI.initialized() | |
| 1719 | let names = try FileManager.default.contentsOfDirectory(atPath: cli.dir.path) | |
| 1720 | #expect(names == ["vault.kc"]) | |
| 1721 | } | |
| 1722 | } | |
| 1723 | ``` | |
| 1724 | ||
| 1725 | `Tests/KeycaskCLITests/PathsTests.swift` tests `Paths` in process. It needs `@testable import keycask`, which works because the test target depends on the executable target: | |
| 1726 | ||
| 1727 | ```swift | |
| 1728 | import Foundation | |
| 1729 | import Testing | |
| 1730 | ||
| 1731 | @testable import keycask | |
| 1732 | ||
| 1733 | @Suite struct PathsTests { | |
| 1734 | @Test func overrideWinsOverEverything() { | |
| 1735 | let url = Paths.vaultURL( | |
| 1736 | override: "/x/v.kc", environment: ["KEYCASK_VAULT": "/y", "HOME": "/h"]) | |
| 1737 | #expect(url.path == "/x/v.kc") | |
| 1738 | } | |
| 1739 | ||
| 1740 | @Test func environmentVariableWinsOverDefaults() { | |
| 1741 | let url = Paths.vaultURL(override: nil, environment: ["KEYCASK_VAULT": "/y/v.kc", "HOME": "/h"]) | |
| 1742 | #expect(url.path == "/y/v.kc") | |
| 1743 | } | |
| 1744 | ||
| 1745 | #if os(Windows) | |
| 1746 | @Test func windowsUsesLocalAppData() { | |
| 1747 | let url = Paths.vaultURL(override: nil, environment: ["LOCALAPPDATA": "C:\\Users\\u\\AppData\\Local"]) | |
| 1748 | #expect(url.path.hasSuffix("keycask/vault.kc") || url.path.hasSuffix("keycask\\vault.kc")) | |
| 1749 | } | |
| 1750 | #else | |
| 1751 | @Test func xdgDataHomeIsUsedWhenSet() { | |
| 1752 | let url = Paths.vaultURL(override: nil, environment: ["XDG_DATA_HOME": "/d", "HOME": "/h"]) | |
| 1753 | #expect(url.path == "/d/keycask/vault.kc") | |
| 1754 | } | |
| 1755 | ||
| 1756 | @Test func homeFallback() { | |
| 1757 | let url = Paths.vaultURL(override: nil, environment: ["HOME": "/h"]) | |
| 1758 | #expect(url.path == "/h/.local/share/keycask/vault.kc") | |
| 1759 | } | |
| 1760 | #endif | |
| 1761 | } | |
| 1762 | ``` | |
| 1763 | ||
| 1764 | - [ ] **Step 4: Run tests to verify they fail** | |
| 1765 | ||
| 1766 | Run: `swift test --filter 'InitTests|PathsTests'` | |
| 1767 | Expected: compile error, `Paths` not found. | |
| 1768 | ||
| 1769 | - [ ] **Step 5: Write Paths.swift** | |
| 1770 | ||
| 1771 | ```swift | |
| 1772 | import Foundation | |
| 1773 | ||
| 1774 | enum Paths { | |
| 1775 | static let variable = "KEYCASK_VAULT" | |
| 1776 | ||
| 1777 | static func vaultURL( | |
| 1778 | override: String?, environment: [String: String] = ProcessInfo.processInfo.environment | |
| 1779 | ) -> URL { | |
| 1780 | if let override { return URL(fileURLWithPath: override) } | |
| 1781 | if let env = environment[variable], !env.isEmpty { return URL(fileURLWithPath: env) } | |
| 1782 | return defaultDirectory(environment: environment) | |
| 1783 | .appendingPathComponent("keycask").appendingPathComponent("vault.kc") | |
| 1784 | } | |
| 1785 | ||
| 1786 | private static func defaultDirectory(environment: [String: String]) -> URL { | |
| 1787 | #if os(Windows) | |
| 1788 | let base = environment["LOCALAPPDATA"] ?? environment["USERPROFILE"] ?? "." | |
| 1789 | return URL(fileURLWithPath: base) | |
| 1790 | #else | |
| 1791 | if let xdg = environment["XDG_DATA_HOME"], !xdg.isEmpty { | |
| 1792 | return URL(fileURLWithPath: xdg) | |
| 1793 | } | |
| 1794 | let home = environment["HOME"] ?? "." | |
| 1795 | return URL(fileURLWithPath: home).appendingPathComponent(".local/share") | |
| 1796 | #endif | |
| 1797 | } | |
| 1798 | } | |
| 1799 | ``` | |
| 1800 | ||
| 1801 | - [ ] **Step 6: Write Terminal.swift** | |
| 1802 | ||
| 1803 | ```swift | |
| 1804 | import Foundation | |
| 1805 | import KeycaskCore | |
| 1806 | ||
| 1807 | #if canImport(Darwin) | |
| 1808 | import Darwin | |
| 1809 | #elseif canImport(Glibc) | |
| 1810 | import Glibc | |
| 1811 | #elseif canImport(Musl) | |
| 1812 | import Musl | |
| 1813 | #elseif os(Windows) | |
| 1814 | import CRT | |
| 1815 | import WinSDK | |
| 1816 | #endif | |
| 1817 | ||
| 1818 | enum Terminal { | |
| 1819 | static var stdinIsTTY: Bool { | |
| 1820 | #if os(Windows) | |
| 1821 | return _isatty(_fileno(stdin)) != 0 | |
| 1822 | #else | |
| 1823 | return isatty(STDIN_FILENO) != 0 | |
| 1824 | #endif | |
| 1825 | } | |
| 1826 | ||
| 1827 | static func write(_ text: String) { | |
| 1828 | FileHandle.standardError.write(Data(text.utf8)) | |
| 1829 | } | |
| 1830 | ||
| 1831 | static func readLine(prompt: String) -> String? { | |
| 1832 | write(prompt) | |
| 1833 | return Swift.readLine(strippingNewline: true) | |
| 1834 | } | |
| 1835 | ||
| 1836 | static func confirm(_ question: String) -> Bool { | |
| 1837 | guard let answer = readLine(prompt: question + " [y/N] ") else { return false } | |
| 1838 | return answer.lowercased().hasPrefix("y") | |
| 1839 | } | |
| 1840 | ||
| 1841 | static func readSecretLine(prompt: String) throws -> String { | |
| 1842 | write(prompt) | |
| 1843 | defer { write("\n") } | |
| 1844 | return try withEchoDisabled { Swift.readLine(strippingNewline: true) ?? "" } | |
| 1845 | } | |
| 1846 | ||
| 1847 | #if os(Windows) | |
| 1848 | private static func withEchoDisabled<T>(_ body: () throws -> T) throws -> T { | |
| 1849 | let handle = GetStdHandle(DWORD(bitPattern: -10)) | |
| 1850 | var mode: DWORD = 0 | |
| 1851 | guard GetConsoleMode(handle, &mode).boolValue else { | |
| 1852 | throw KeycaskError.io("GetConsoleMode failed") | |
| 1853 | } | |
| 1854 | SetConsoleMode(handle, mode & ~DWORD(ENABLE_ECHO_INPUT)) | |
| 1855 | defer { SetConsoleMode(handle, mode) } | |
| 1856 | return try body() | |
| 1857 | } | |
| 1858 | #else | |
| 1859 | private static func withEchoDisabled<T>(_ body: () throws -> T) throws -> T { | |
| 1860 | var original = termios() | |
| 1861 | guard tcgetattr(STDIN_FILENO, &original) == 0 else { | |
| 1862 | throw KeycaskError.io("tcgetattr failed") | |
| 1863 | } | |
| 1864 | var quiet = original | |
| 1865 | quiet.c_lflag &= ~tcflag_t(ECHO) | |
| 1866 | tcsetattr(STDIN_FILENO, TCSANOW, &quiet) | |
| 1867 | defer { tcsetattr(STDIN_FILENO, TCSANOW, &original) } | |
| 1868 | return try body() | |
| 1869 | } | |
| 1870 | #endif | |
| 1871 | } | |
| 1872 | ``` | |
| 1873 | ||
| 1874 | - [ ] **Step 7: Write Passphrase.swift** | |
| 1875 | ||
| 1876 | ```swift | |
| 1877 | import Foundation | |
| 1878 | import KeycaskCore | |
| 1879 | ||
| 1880 | enum Passphrase { | |
| 1881 | static let variable = "KEYCASK_PASSPHRASE" | |
| 1882 | ||
| 1883 | static func obtain( | |
| 1884 | confirm: Bool, environment: [String: String] = ProcessInfo.processInfo.environment | |
| 1885 | ) throws -> String { | |
| 1886 | if let fromEnv = environment[variable] { | |
| 1887 | return try validated(fromEnv) | |
| 1888 | } | |
| 1889 | guard Terminal.stdinIsTTY else { | |
| 1890 | throw KeycaskError.usage("no passphrase: set \(variable) or run on a terminal") | |
| 1891 | } | |
| 1892 | let first = try Terminal.readSecretLine(prompt: "Passphrase: ") | |
| 1893 | if confirm { | |
| 1894 | let second = try Terminal.readSecretLine(prompt: "Confirm passphrase: ") | |
| 1895 | guard first == second else { throw KeycaskError.failure("passphrases do not match") } | |
| 1896 | } | |
| 1897 | return try validated(first) | |
| 1898 | } | |
| 1899 | ||
| 1900 | private static func validated(_ passphrase: String) throws -> String { | |
| 1901 | guard !passphrase.isEmpty else { throw KeycaskError.failure("passphrase is empty") } | |
| 1902 | return passphrase | |
| 1903 | } | |
| 1904 | } | |
| 1905 | ``` | |
| 1906 | ||
| 1907 | - [ ] **Step 8: Write AtomicFile.swift** | |
| 1908 | ||
| 1909 | ```swift | |
| 1910 | import Foundation | |
| 1911 | import KeycaskCore | |
| 1912 | ||
| 1913 | #if canImport(Darwin) | |
| 1914 | import Darwin | |
| 1915 | #elseif canImport(Glibc) | |
| 1916 | import Glibc | |
| 1917 | #elseif canImport(Musl) | |
| 1918 | import Musl | |
| 1919 | #elseif os(Windows) | |
| 1920 | import WinSDK | |
| 1921 | #endif | |
| 1922 | ||
| 1923 | enum AtomicFile { | |
| 1924 | static func write(_ data: Data, to url: URL) throws { | |
| 1925 | let directory = url.deletingLastPathComponent() | |
| 1926 | let temp = url.appendingPathExtension("tmp") | |
| 1927 | do { | |
| 1928 | try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) | |
| 1929 | try writePrivate(data, to: temp) | |
| 1930 | try replace(url, with: temp) | |
| 1931 | } catch let error as KeycaskError { | |
| 1932 | try? FileManager.default.removeItem(at: temp) | |
| 1933 | throw error | |
| 1934 | } catch { | |
| 1935 | try? FileManager.default.removeItem(at: temp) | |
| 1936 | throw KeycaskError.io("write \(url.path): \(error)") | |
| 1937 | } | |
| 1938 | } | |
| 1939 | ||
| 1940 | #if os(Windows) | |
| 1941 | private static func writePrivate(_ data: Data, to url: URL) throws { | |
| 1942 | try data.write(to: url) | |
| 1943 | let handle = try FileHandle(forWritingTo: url) | |
| 1944 | try handle.synchronize() | |
| 1945 | try handle.close() | |
| 1946 | } | |
| 1947 | ||
| 1948 | private static func replace(_ target: URL, with temp: URL) throws { | |
| 1949 | let ok = temp.path.withCString(encodedAs: UTF16.self) { src in | |
| 1950 | target.path.withCString(encodedAs: UTF16.self) { dst in | |
| 1951 | MoveFileExW(src, dst, DWORD(MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) | |
| 1952 | } | |
| 1953 | } | |
| 1954 | guard ok.boolValue else { throw KeycaskError.io("rename \(temp.path): error \(GetLastError())") } | |
| 1955 | } | |
| 1956 | #else | |
| 1957 | private static func writePrivate(_ data: Data, to url: URL) throws { | |
| 1958 | let fd = open(url.path, O_WRONLY | O_CREAT | O_TRUNC, 0o600) | |
| 1959 | guard fd >= 0 else { | |
| 1960 | throw KeycaskError.io("open \(url.path): \(String(cString: strerror(errno)))") | |
| 1961 | } | |
| 1962 | let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true) | |
| 1963 | try handle.write(contentsOf: data) | |
| 1964 | try handle.synchronize() | |
| 1965 | try handle.close() | |
| 1966 | } | |
| 1967 | ||
| 1968 | private static func replace(_ target: URL, with temp: URL) throws { | |
| 1969 | guard rename(temp.path, target.path) == 0 else { | |
| 1970 | throw KeycaskError.io("rename \(temp.path): \(String(cString: strerror(errno)))") | |
| 1971 | } | |
| 1972 | } | |
| 1973 | #endif | |
| 1974 | } | |
| 1975 | ``` | |
| 1976 | ||
| 1977 | - [ ] **Step 9: Write OpenVault.swift** | |
| 1978 | ||
| 1979 | ```swift | |
| 1980 | import Foundation | |
| 1981 | import KeycaskCore | |
| 1982 | ||
| 1983 | struct OpenVault { | |
| 1984 | var vault: Vault | |
| 1985 | let kdf: Envelope.KDFParams | |
| 1986 | let url: URL | |
| 1987 | let passphrase: String | |
| 1988 | ||
| 1989 | static func load(_ options: GlobalOptions) throws -> OpenVault { | |
| 1990 | let url = Paths.vaultURL(override: options.vault) | |
| 1991 | let data: Data | |
| 1992 | do { | |
| 1993 | data = try Data(contentsOf: url) | |
| 1994 | } catch let error as CocoaError where error.code == .fileReadNoSuchFile { | |
| 1995 | throw KeycaskError.noVault(url.path) | |
| 1996 | } catch { | |
| 1997 | if !FileManager.default.fileExists(atPath: url.path) { | |
| 1998 | throw KeycaskError.noVault(url.path) | |
| 1999 | } | |
| 2000 | throw KeycaskError.io("read \(url.path): \(error)") | |
| 2001 | } | |
| 2002 | let envelope = try Envelope(parsing: data) | |
| 2003 | let passphrase = try Passphrase.obtain(confirm: false) | |
| 2004 | let plaintext = try envelope.open(passphrase: passphrase) | |
| 2005 | let vault = try VaultCodec.decode(plaintext) | |
| 2006 | return OpenVault(vault: vault, kdf: envelope.kdf, url: url, passphrase: passphrase) | |
| 2007 | } | |
| 2008 | ||
| 2009 | static func create(_ options: GlobalOptions) throws -> URL { | |
| 2010 | let url = Paths.vaultURL(override: options.vault) | |
| 2011 | guard !FileManager.default.fileExists(atPath: url.path) else { | |
| 2012 | throw KeycaskError.vaultExists(url.path) | |
| 2013 | } | |
| 2014 | let passphrase = try Passphrase.obtain(confirm: true) | |
| 2015 | let fresh = OpenVault(vault: Vault(), kdf: .fresh(), url: url, passphrase: passphrase) | |
| 2016 | try fresh.save() | |
| 2017 | return url | |
| 2018 | } | |
| 2019 | ||
| 2020 | func save() throws { | |
| 2021 | let plaintext = try VaultCodec.encode(vault) | |
| 2022 | let envelope = try Envelope.seal(plaintext, passphrase: passphrase, kdf: kdf) | |
| 2023 | try AtomicFile.write(try envelope.encoded(), to: url) | |
| 2024 | } | |
| 2025 | } | |
| 2026 | ``` | |
| 2027 | ||
| 2028 | - [ ] **Step 10: Write Keycask.swift and Commands/Init.swift** | |
| 2029 | ||
| 2030 | `Sources/keycask/Keycask.swift`: | |
| 2031 | ||
| 2032 | ```swift | |
| 2033 | import ArgumentParser | |
| 2034 | ||
| 2035 | struct GlobalOptions: ParsableArguments { | |
| 2036 | @Option(name: .long, help: "Path to the vault file.") | |
| 2037 | var vault: String? | |
| 2038 | } | |
| 2039 | ||
| 2040 | struct Keycask: ParsableCommand { | |
| 2041 | static let configuration = CommandConfiguration( | |
| 2042 | commandName: "keycask", | |
| 2043 | abstract: "Command-line password manager. One passphrase-encrypted vault file.", | |
| 2044 | subcommands: [Init.self] | |
| 2045 | ) | |
| 2046 | } | |
| 2047 | ``` | |
| 2048 | ||
| 2049 | `Sources/keycask/Commands/Init.swift`: | |
| 2050 | ||
| 2051 | ```swift | |
| 2052 | import ArgumentParser | |
| 2053 | ||
| 2054 | struct Init: ParsableCommand { | |
| 2055 | static let configuration = CommandConfiguration(abstract: "Create an empty vault.") | |
| 2056 | ||
| 2057 | @OptionGroup var global: GlobalOptions | |
| 2058 | ||
| 2059 | func run() throws { | |
| 2060 | let url = try OpenVault.create(global) | |
| 2061 | print("created \(url.path)") | |
| 2062 | } | |
| 2063 | } | |
| 2064 | ``` | |
| 2065 | ||
| 2066 | - [ ] **Step 11: Write main.swift** | |
| 2067 | ||
| 2068 | ```swift | |
| 2069 | import ArgumentParser | |
| 2070 | import Foundation | |
| 2071 | import KeycaskCore | |
| 2072 | ||
| 2073 | func fail(_ text: String, code: Int32) -> Never { | |
| 2074 | FileHandle.standardError.write(Data((text + "\n").utf8)) | |
| 2075 | exit(code) | |
| 2076 | } | |
| 2077 | ||
| 2078 | do { | |
| 2079 | var command = try Keycask.parseAsRoot() | |
| 2080 | try command.run() | |
| 2081 | } catch let error as KeycaskError { | |
| 2082 | fail(error.message, code: error.exitCode) | |
| 2083 | } catch { | |
| 2084 | let text = Keycask.fullMessage(for: error) | |
| 2085 | if Keycask.exitCode(for: error).isSuccess { | |
| 2086 | print(text) | |
| 2087 | exit(0) | |
| 2088 | } | |
| 2089 | fail(text, code: 2) | |
| 2090 | } | |
| 2091 | ``` | |
| 2092 | ||
| 2093 | - [ ] **Step 12: Run tests** | |
| 2094 | ||
| 2095 | Run: `swift test --filter 'InitTests|PathsTests'` | |
| 2096 | Expected: all pass. The `init` tests take about half a second each because of 600000 PBKDF2 rounds; that is expected. | |
| 2097 | ||
| 2098 | - [ ] **Step 13: Lint and commit** | |
| 2099 | ||
| 2100 | ```bash | |
| 2101 | swift format lint --strict --recursive Sources Tests | |
| 2102 | git add Sources/keycask Tests/KeycaskCLITests | |
| 2103 | git commit -m "Add CLI skeleton with init, paths, passphrase, atomic write" | |
| 2104 | ``` | |
| 2105 | ||
| 2106 | --- | |
| 2107 | ||
| 2108 | ### Task 10: `add`, `show`, and output formatting | |
| 2109 | ||
| 2110 | **Files:** | |
| 2111 | - Create: `Sources/keycask/Output.swift` | |
| 2112 | - Create: `Sources/keycask/Commands/Add.swift` | |
| 2113 | - Create: `Sources/keycask/Commands/Show.swift` | |
| 2114 | - Modify: `Sources/keycask/Keycask.swift` (register subcommands) | |
| 2115 | - Create: `Tests/KeycaskCLITests/AddShowTests.swift` | |
| 2116 | ||
| 2117 | **Interfaces:** | |
| 2118 | - Consumes: `OpenVault`, `Generator`, `Entry`, `Terminal`, `VaultCodec.makeEncoder()`. | |
| 2119 | - Produces: | |
| 2120 | ||
| 2121 | ```swift | |
| 2122 | enum Output { | |
| 2123 | static let mask = "********" | |
| 2124 | static func masked(_ entry: Entry, reveal: Bool) -> Entry | |
| 2125 | static func text(_ entry: Entry, reveal: Bool) -> String // "field: value" lines | |
| 2126 | static func table(_ entries: [Entry]) -> String // id name username url | |
| 2127 | static func json(_ entries: [Entry], reveal: Bool) throws -> String | |
| 2128 | static func json(_ entry: Entry, reveal: Bool) throws -> String | |
| 2129 | static func field(_ entry: Entry, named: String) throws -> String // usage error for unknown field | |
| 2130 | } | |
| 2131 | enum PasswordInput { | |
| 2132 | static func read(prompt: String) throws -> String // TTY: hidden prompt; else first line of stdin | |
| 2133 | } | |
| 2134 | struct PasswordOptions: ParsableArguments { var generate: Bool; var length: Int?; var words: Int?; func validate(); func newPassword() throws -> String? } | |
| 2135 | ``` | |
| 2136 | ||
| 2137 | Non-TTY password entry: when stdin is not a terminal, `add` and `edit --password` read the password as the first line of stdin. Add this sentence to the spec's CLI section in this task. | |
| 2138 | ||
| 2139 | - [ ] **Step 1: Write the failing tests** | |
| 2140 | ||
| 2141 | `Tests/KeycaskCLITests/AddShowTests.swift`: | |
| 2142 | ||
| 2143 | ```swift | |
| 2144 | import Foundation | |
| 2145 | import Testing | |
| 2146 | ||
| 2147 | @Suite struct AddShowTests { | |
| 2148 | @Test func addReadsPasswordFromStdinAndPrintsID() throws { | |
| 2149 | let cli = try CLI.initialized() | |
| 2150 | let r = try cli.run(["add", "github", "-u", "cmc", "--url", "https://github.com", "--tag", "dev"], | |
| 2151 | stdin: "hunter2\n") | |
| 2152 | #expect(r.status == 0) | |
| 2153 | let id = r.stdout.trimmingCharacters(in: .whitespacesAndNewlines) | |
| 2154 | #expect(id.count == 8) | |
| 2155 | ||
| 2156 | let shown = try cli.run(["show", id]) | |
| 2157 | #expect(shown.status == 0) | |
| 2158 | #expect(shown.stdout.contains("name: github")) | |
| 2159 | #expect(shown.stdout.contains("username: cmc")) | |
| 2160 | #expect(shown.stdout.contains("password: ********")) | |
| 2161 | #expect(shown.stdout.contains("tags: dev")) | |
| 2162 | #expect(!shown.stdout.contains("hunter2")) | |
| 2163 | } | |
| 2164 | ||
| 2165 | @Test func showByNameRevealAndField() throws { | |
| 2166 | let cli = try CLI.initialized() | |
| 2167 | try cli.run(["add", "github"], stdin: "hunter2\n") | |
| 2168 | let revealed = try cli.run(["show", "github", "--reveal"]) | |
| 2169 | #expect(revealed.stdout.contains("password: hunter2")) | |
| 2170 | let field = try cli.run(["show", "github", "--field", "password"]) | |
| 2171 | #expect(field.stdout == "hunter2\n") | |
| 2172 | let missing = try cli.run(["show", "github", "--field", "url"]) | |
| 2173 | #expect(missing.status == 0) | |
| 2174 | #expect(missing.stdout == "\n") | |
| 2175 | let unknown = try cli.run(["show", "github", "--field", "nope"]) | |
| 2176 | #expect(unknown.status == 2) | |
| 2177 | } | |
| 2178 | ||
| 2179 | @Test func jsonMasksUnlessReveal() throws { | |
| 2180 | let cli = try CLI.initialized() | |
| 2181 | try cli.run(["add", "github", "-u", "cmc"], stdin: "hunter2\n") | |
| 2182 | let masked = try cli.run(["show", "github", "--json"]) | |
| 2183 | let obj = try JSONSerialization.jsonObject(with: Data(masked.stdout.utf8)) as! [String: Any] | |
| 2184 | #expect(obj["name"] as? String == "github") | |
| 2185 | #expect(obj["username"] as? String == "cmc") | |
| 2186 | #expect(obj["password"] as? String == "********") | |
| 2187 | #expect((obj["id"] as? String)?.count == 8) | |
| 2188 | #expect((obj["created"] as? String)?.hasSuffix("Z") == true) | |
| 2189 | let revealed = try cli.run(["show", "github", "--json", "--reveal"]) | |
| 2190 | let obj2 = try JSONSerialization.jsonObject(with: Data(revealed.stdout.utf8)) as! [String: Any] | |
| 2191 | #expect(obj2["password"] as? String == "hunter2") | |
| 2192 | } | |
| 2193 | ||
| 2194 | @Test func addGenerateAndWords() throws { | |
| 2195 | let cli = try CLI.initialized() | |
| 2196 | try cli.run(["add", "a", "--generate"]) | |
| 2197 | try cli.run(["add", "b", "--generate", "--length", "40"]) | |
| 2198 | try cli.run(["add", "c", "--words", "4"]) | |
| 2199 | #expect(try cli.run(["show", "a", "--field", "password"]).stdout.count == 25) | |
| 2200 | #expect(try cli.run(["show", "b", "--field", "password"]).stdout.count == 41) | |
| 2201 | let words = try cli.run(["show", "c", "--field", "password"]).stdout | |
| 2202 | .trimmingCharacters(in: .newlines).split(separator: "-") | |
| 2203 | #expect(words.count == 4) | |
| 2204 | } | |
| 2205 | ||
| 2206 | @Test func generateAndWordsTogetherIsUsageError() throws { | |
| 2207 | let cli = try CLI.initialized() | |
| 2208 | let r = try cli.run(["add", "a", "--generate", "--words", "3"]) | |
| 2209 | #expect(r.status == 2) | |
| 2210 | } | |
| 2211 | ||
| 2212 | @Test func duplicateNamesAreAllowedAndAmbiguousOnShow() throws { | |
| 2213 | let cli = try CLI.initialized() | |
| 2214 | let a = try cli.run(["add", "gh", "-u", "one", "--generate"]).stdout.trimmingCharacters(in: .newlines) | |
| 2215 | let b = try cli.run(["add", "gh", "-u", "two", "--generate"]).stdout.trimmingCharacters(in: .newlines) | |
| 2216 | let r = try cli.run(["show", "gh"]) | |
| 2217 | #expect(r.status == 5) | |
| 2218 | #expect(r.stderr.contains(a) && r.stderr.contains(b)) | |
| 2219 | #expect(try cli.run(["show", a]).stdout.contains("username: one")) | |
| 2220 | } | |
| 2221 | ||
| 2222 | @Test func missingEntryIsNotFound() throws { | |
| 2223 | let cli = try CLI.initialized() | |
| 2224 | let r = try cli.run(["show", "nope"]) | |
| 2225 | #expect(r.status == 3) | |
| 2226 | #expect(r.stderr == "nope: not found\n") | |
| 2227 | } | |
| 2228 | ||
| 2229 | @Test func wrongPassphraseCannotDecrypt() throws { | |
| 2230 | let cli = try CLI.initialized() | |
| 2231 | let r = try cli.run(["show", "x"], passphrase: "wrong") | |
| 2232 | #expect(r.status == 4) | |
| 2233 | #expect(r.stderr.contains("cannot decrypt")) | |
| 2234 | } | |
| 2235 | ||
| 2236 | @Test func missingVaultIsNotFound() throws { | |
| 2237 | let cli = try CLI() | |
| 2238 | let r = try cli.run(["show", "x"]) | |
| 2239 | #expect(r.status == 3) | |
| 2240 | #expect(r.stderr.contains("keycask init")) | |
| 2241 | } | |
| 2242 | ||
| 2243 | @Test func corruptVaultIsFailure() throws { | |
| 2244 | let cli = try CLI.initialized() | |
| 2245 | try Data("{}".utf8).write(to: cli.vault) | |
| 2246 | let r = try cli.run(["show", "x"]) | |
| 2247 | #expect(r.status == 1) | |
| 2248 | #expect(r.stderr.hasPrefix("vault is corrupt")) | |
| 2249 | } | |
| 2250 | } | |
| 2251 | ``` | |
| 2252 | ||
| 2253 | - [ ] **Step 2: Run tests to verify they fail** | |
| 2254 | ||
| 2255 | Run: `swift test --filter AddShowTests` | |
| 2256 | Expected: failures, `add` is an unknown subcommand (exit 2). | |
| 2257 | ||
| 2258 | - [ ] **Step 3: Write Output.swift** | |
| 2259 | ||
| 2260 | ```swift | |
| 2261 | import Foundation | |
| 2262 | import KeycaskCore | |
| 2263 | ||
| 2264 | enum Output { | |
| 2265 | static let mask = "********" | |
| 2266 | ||
| 2267 | static func masked(_ entry: Entry, reveal: Bool) -> Entry { | |
| 2268 | guard !reveal else { return entry } | |
| 2269 | var copy = entry | |
| 2270 | copy.password = mask | |
| 2271 | return copy | |
| 2272 | } | |
| 2273 | ||
| 2274 | static func text(_ entry: Entry, reveal: Bool) -> String { | |
| 2275 | let e = masked(entry, reveal: reveal) | |
| 2276 | var lines = ["id: \(e.id.rawValue)", "name: \(e.name)"] | |
| 2277 | if let u = e.username { lines.append("username: \(u)") } | |
| 2278 | lines.append("password: \(e.password)") | |
| 2279 | if let u = e.url { lines.append("url: \(u)") } | |
| 2280 | if !e.tags.isEmpty { lines.append("tags: \(e.tags.joined(separator: ", "))") } | |
| 2281 | if let n = e.notes { lines.append("notes: \(n)") } | |
| 2282 | lines.append("created: \(iso(e.created))") | |
| 2283 | lines.append("updated: \(iso(e.updated))") | |
| 2284 | return lines.joined(separator: "\n") + "\n" | |
| 2285 | } | |
| 2286 | ||
| 2287 | static func table(_ entries: [Entry]) -> String { | |
| 2288 | guard !entries.isEmpty else { return "" } | |
| 2289 | let rows = entries.map { [$0.id.rawValue, $0.name, $0.username ?? "", $0.url ?? ""] } | |
| 2290 | let widths = (0..<3).map { col in rows.map { $0[col].count }.max() ?? 0 } | |
| 2291 | return rows.map { row in | |
| 2292 | let padded = (0..<3).map { row[$0].padding(toLength: widths[$0], withPad: " ", startingAt: 0) } | |
| 2293 | return (padded + [row[3]]).joined(separator: " ") | |
| 2294 | .trimmingCharacters(in: .whitespaces) | |
| 2295 | }.joined(separator: "\n") + "\n" | |
| 2296 | } | |
| 2297 | ||
| 2298 | static func json(_ entries: [Entry], reveal: Bool) throws -> String { | |
| 2299 | try encode(entries.map { masked($0, reveal: reveal) }) | |
| 2300 | } | |
| 2301 | ||
| 2302 | static func json(_ entry: Entry, reveal: Bool) throws -> String { | |
| 2303 | try encode(masked(entry, reveal: reveal)) | |
| 2304 | } | |
| 2305 | ||
| 2306 | static func field(_ entry: Entry, named name: String) throws -> String { | |
| 2307 | switch name { | |
| 2308 | case "id": entry.id.rawValue | |
| 2309 | case "name": entry.name | |
| 2310 | case "username": entry.username ?? "" | |
| 2311 | case "password": entry.password | |
| 2312 | case "url": entry.url ?? "" | |
| 2313 | case "notes": entry.notes ?? "" | |
| 2314 | case "tags": entry.tags.joined(separator: ",") | |
| 2315 | case "created": iso(entry.created) | |
| 2316 | case "updated": iso(entry.updated) | |
| 2317 | default: throw KeycaskError.usage("unknown field \(name)") | |
| 2318 | } | |
| 2319 | } | |
| 2320 | ||
| 2321 | private static func encode(_ value: some Encodable) throws -> String { | |
| 2322 | let encoder = VaultCodec.makeEncoder() | |
| 2323 | encoder.outputFormatting.insert(.prettyPrinted) | |
| 2324 | do { | |
| 2325 | return String(decoding: try encoder.encode(value), as: UTF8.self) + "\n" | |
| 2326 | } catch { | |
| 2327 | throw KeycaskError.io("encode json: \(error)") | |
| 2328 | } | |
| 2329 | } | |
| 2330 | ||
| 2331 | private static func iso(_ date: Date) -> String { | |
| 2332 | date.formatted(.iso8601) | |
| 2333 | } | |
| 2334 | } | |
| 2335 | ``` | |
| 2336 | ||
| 2337 | - [ ] **Step 4: Write password input and the shared password options** | |
| 2338 | ||
| 2339 | Add to `Sources/keycask/Commands/Add.swift`: | |
| 2340 | ||
| 2341 | ```swift | |
| 2342 | import ArgumentParser | |
| 2343 | import Foundation | |
| 2344 | import KeycaskCore | |
| 2345 | ||
| 2346 | enum PasswordInput { | |
| 2347 | static func read(prompt: String) throws -> String { | |
| 2348 | if Terminal.stdinIsTTY { | |
| 2349 | return try Terminal.readSecretLine(prompt: prompt) | |
| 2350 | } | |
| 2351 | guard let line = Swift.readLine(strippingNewline: true) else { | |
| 2352 | throw KeycaskError.usage("no password: pass one on stdin or run on a terminal") | |
| 2353 | } | |
| 2354 | return line | |
| 2355 | } | |
| 2356 | } | |
| 2357 | ||
| 2358 | struct PasswordOptions: ParsableArguments { | |
| 2359 | @Flag(name: .long, help: "Generate a random password.") | |
| 2360 | var generate = false | |
| 2361 | ||
| 2362 | @Option(name: .long, help: "Length of the generated password (default 24).") | |
| 2363 | var length: Int? | |
| 2364 | ||
| 2365 | @Option(name: .long, help: "Generate a passphrase of this many words instead.") | |
| 2366 | var words: Int? | |
| 2367 | ||
| 2368 | mutating func validate() throws { | |
| 2369 | if generate, words != nil { | |
| 2370 | throw ValidationError("--generate and --words are mutually exclusive") | |
| 2371 | } | |
| 2372 | if let length, length < 1 { throw ValidationError("--length must be at least 1") } | |
| 2373 | if let words, words < 1 { throw ValidationError("--words must be at least 1") } | |
| 2374 | if length != nil, !generate, words == nil { | |
| 2375 | throw ValidationError("--length requires --generate") | |
| 2376 | } | |
| 2377 | } | |
| 2378 | ||
| 2379 | /// nil means the caller must prompt. | |
| 2380 | func newPassword() -> String? { | |
| 2381 | if let words { return Generator.passphrase(words: words) } | |
| 2382 | if generate { return Generator.password(length: length ?? Generator.defaultLength) } | |
| 2383 | return nil | |
| 2384 | } | |
| 2385 | } | |
| 2386 | ||
| 2387 | struct Add: ParsableCommand { | |
| 2388 | static let configuration = CommandConfiguration(abstract: "Add an entry.") | |
| 2389 | ||
| 2390 | @OptionGroup var global: GlobalOptions | |
| 2391 | @Argument(help: "Entry name. Names may repeat; the printed id is unique.") var name: String | |
| 2392 | @Option(name: [.short, .customLong("username")], help: "Username.") var username: String? | |
| 2393 | @Option(name: .long, help: "URL.") var url: String? | |
| 2394 | @Option(name: .long, help: "Notes.") var notes: String? | |
| 2395 | @Option(name: .long, help: "Tag. Repeatable.") var tag: [String] = [] | |
| 2396 | @OptionGroup var password: PasswordOptions | |
| 2397 | ||
| 2398 | func run() throws { | |
| 2399 | var open = try OpenVault.load(global) | |
| 2400 | let secret = try password.newPassword() ?? PasswordInput.read(prompt: "Password: ") | |
| 2401 | var entry = Entry(name: name, username: username, password: secret, url: url, | |
| 2402 | notes: notes, tags: tag) | |
| 2403 | while open.vault.entry(id: entry.id) != nil { | |
| 2404 | entry = Entry(name: name, username: username, password: secret, url: url, | |
| 2405 | notes: notes, tags: tag) | |
| 2406 | } | |
| 2407 | try open.vault.add(entry) | |
| 2408 | try open.save() | |
| 2409 | print(entry.id.rawValue) | |
| 2410 | } | |
| 2411 | } | |
| 2412 | ``` | |
| 2413 | ||
| 2414 | - [ ] **Step 5: Write Commands/Show.swift** | |
| 2415 | ||
| 2416 | ```swift | |
| 2417 | import ArgumentParser | |
| 2418 | import KeycaskCore | |
| 2419 | ||
| 2420 | struct Show: ParsableCommand { | |
| 2421 | static let configuration = CommandConfiguration(abstract: "Show an entry.") | |
| 2422 | ||
| 2423 | @OptionGroup var global: GlobalOptions | |
| 2424 | @Argument(help: "Entry id or name.") var ref: String | |
| 2425 | @Flag(name: .long, help: "Show the password.") var reveal = false | |
| 2426 | @Option(name: .long, help: "Print one field, unmasked.") var field: String? | |
| 2427 | @Flag(name: .long, help: "JSON output.") var json = false | |
| 2428 | ||
| 2429 | func run() throws { | |
| 2430 | let open = try OpenVault.load(global) | |
| 2431 | let entry = try open.vault.resolve(ref) | |
| 2432 | if let field { | |
| 2433 | print(try Output.field(entry, named: field)) | |
| 2434 | } else if json { | |
| 2435 | print(try Output.json(entry, reveal: reveal), terminator: "") | |
| 2436 | } else { | |
| 2437 | print(Output.text(entry, reveal: reveal), terminator: "") | |
| 2438 | } | |
| 2439 | } | |
| 2440 | } | |
| 2441 | ``` | |
| 2442 | ||
| 2443 | - [ ] **Step 6: Register the subcommands** | |
| 2444 | ||
| 2445 | In `Keycask.swift`: `subcommands: [Init.self, Add.self, Show.self]`. | |
| 2446 | ||
| 2447 | - [ ] **Step 7: Amend the spec** | |
| 2448 | ||
| 2449 | In `docs/superpowers/specs/2026-09-17-keycask-design.md`, after the sentence beginning "Passphrase input:", add a paragraph: | |
| 2450 | ||
| 2451 | ``` | |
| 2452 | Password input for `add` and `edit --password`: on a terminal, a hidden | |
| 2453 | prompt. Without a terminal, the first line of stdin. Neither available is | |
| 2454 | exit 2. | |
| 2455 | ``` | |
| 2456 | ||
| 2457 | - [ ] **Step 8: Run tests** | |
| 2458 | ||
| 2459 | Run: `swift test --filter AddShowTests` | |
| 2460 | Expected: 10 tests pass. | |
| 2461 | ||
| 2462 | - [ ] **Step 9: Lint and commit** | |
| 2463 | ||
| 2464 | ```bash | |
| 2465 | swift format lint --strict --recursive Sources Tests | |
| 2466 | git add Sources/keycask Tests/KeycaskCLITests docs | |
| 2467 | git commit -m "Add add and show commands with masked output" | |
| 2468 | ``` | |
| 2469 | ||
| 2470 | --- | |
| 2471 | ||
| 2472 | ### Task 11: `ls` and `find` | |
| 2473 | ||
| 2474 | **Files:** | |
| 2475 | - Create: `Sources/keycask/Commands/Ls.swift` | |
| 2476 | - Create: `Sources/keycask/Commands/Find.swift` | |
| 2477 | - Modify: `Sources/keycask/Keycask.swift` | |
| 2478 | - Create: `Tests/KeycaskCLITests/LsFindTests.swift` | |
| 2479 | ||
| 2480 | **Interfaces:** | |
| 2481 | - Consumes: `OpenVault`, `Output.table`, `Output.json(_:[Entry])`, `Vault.filter(tag:)`, `Vault.search`, `Vault.sortedEntries`. | |
| 2482 | ||
| 2483 | - [ ] **Step 1: Write the failing tests** | |
| 2484 | ||
| 2485 | ```swift | |
| 2486 | import Foundation | |
| 2487 | import Testing | |
| 2488 | ||
| 2489 | @Suite struct LsFindTests { | |
| 2490 | func seeded() throws -> CLI { | |
| 2491 | let cli = try CLI.initialized() | |
| 2492 | try cli.run(["add", "github", "-u", "cmc", "--url", "https://github.com", "--tag", "Dev", "--generate"]) | |
| 2493 | try cli.run(["add", "bank", "--url", "https://bank.example", "--notes", "downtown branch", "--generate"]) | |
| 2494 | try cli.run(["add", "Alpha", "--tag", "dev", "--generate"]) | |
| 2495 | return cli | |
| 2496 | } | |
| 2497 | ||
| 2498 | @Test func lsSortsByNameAndShowsColumns() throws { | |
| 2499 | let cli = try seeded() | |
| 2500 | let r = try cli.run(["ls"]) | |
| 2501 | #expect(r.status == 0) | |
| 2502 | let names = r.lines.map { String($0.split(separator: " ", omittingEmptySubsequences: true)[1]) } | |
| 2503 | #expect(names == ["Alpha", "bank", "github"]) | |
| 2504 | #expect(r.stdout.contains("cmc")) | |
| 2505 | #expect(r.stdout.contains("https://github.com")) | |
| 2506 | } | |
| 2507 | ||
| 2508 | @Test func lsTagFilterIsCaseInsensitive() throws { | |
| 2509 | let cli = try seeded() | |
| 2510 | let r = try cli.run(["ls", "--tag", "DEV"]) | |
| 2511 | #expect(r.lines.count == 2) | |
| 2512 | #expect(!r.stdout.contains("bank")) | |
| 2513 | } | |
| 2514 | ||
| 2515 | @Test func lsJsonIsAnArrayWithMaskedPasswords() throws { | |
| 2516 | let cli = try seeded() | |
| 2517 | let r = try cli.run(["ls", "--json"]) | |
| 2518 | let arr = try JSONSerialization.jsonObject(with: Data(r.stdout.utf8)) as! [[String: Any]] | |
| 2519 | #expect(arr.count == 3) | |
| 2520 | #expect(arr.allSatisfy { $0["password"] as? String == "********" }) | |
| 2521 | } | |
| 2522 | ||
| 2523 | @Test func emptyVaultListsNothing() throws { | |
| 2524 | let cli = try CLI.initialized() | |
| 2525 | let r = try cli.run(["ls"]) | |
| 2526 | #expect(r.status == 0) | |
| 2527 | #expect(r.stdout == "") | |
| 2528 | let j = try cli.run(["ls", "--json"]) | |
| 2529 | #expect(j.stdout.trimmingCharacters(in: .whitespacesAndNewlines) == "[]") | |
| 2530 | } | |
| 2531 | ||
| 2532 | @Test func findMatchesNotesURLTagsCaseInsensitively() throws { | |
| 2533 | let cli = try seeded() | |
| 2534 | #expect(try cli.run(["find", "DOWNTOWN"]).lines.count == 1) | |
| 2535 | #expect(try cli.run(["find", "github.com"]).lines.count == 1) | |
| 2536 | #expect(try cli.run(["find", "dev"]).lines.count == 2) | |
| 2537 | let none = try cli.run(["find", "zzz"]) | |
| 2538 | #expect(none.status == 0) | |
| 2539 | #expect(none.stdout == "") | |
| 2540 | } | |
| 2541 | ||
| 2542 | @Test func findJson() throws { | |
| 2543 | let cli = try seeded() | |
| 2544 | let r = try cli.run(["find", "bank", "--json"]) | |
| 2545 | let arr = try JSONSerialization.jsonObject(with: Data(r.stdout.utf8)) as! [[String: Any]] | |
| 2546 | #expect(arr.count == 1) | |
| 2547 | #expect(arr[0]["name"] as? String == "bank") | |
| 2548 | } | |
| 2549 | } | |
| 2550 | ``` | |
| 2551 | ||
| 2552 | - [ ] **Step 2: Run tests to verify they fail** | |
| 2553 | ||
| 2554 | Run: `swift test --filter LsFindTests` | |
| 2555 | Expected: failures, unknown subcommand. | |
| 2556 | ||
| 2557 | - [ ] **Step 3: Write Ls.swift and Find.swift** | |
| 2558 | ||
| 2559 | `Commands/Ls.swift`: | |
| 2560 | ||
| 2561 | ```swift | |
| 2562 | import ArgumentParser | |
| 2563 | import KeycaskCore | |
| 2564 | ||
| 2565 | struct Ls: ParsableCommand { | |
| 2566 | static let configuration = CommandConfiguration(abstract: "List entries.") | |
| 2567 | ||
| 2568 | @OptionGroup var global: GlobalOptions | |
| 2569 | @Option(name: .long, help: "Only entries with this tag.") var tag: String? | |
| 2570 | @Flag(name: .long, help: "JSON output.") var json = false | |
| 2571 | ||
| 2572 | func run() throws { | |
| 2573 | let open = try OpenVault.load(global) | |
| 2574 | let entries = tag.map { open.vault.filter(tag: $0) } ?? open.vault.sortedEntries | |
| 2575 | if json { | |
| 2576 | print(try Output.json(entries, reveal: false), terminator: "") | |
| 2577 | } else { | |
| 2578 | print(Output.table(entries), terminator: "") | |
| 2579 | } | |
| 2580 | } | |
| 2581 | } | |
| 2582 | ``` | |
| 2583 | ||
| 2584 | `Commands/Find.swift`: | |
| 2585 | ||
| 2586 | ```swift | |
| 2587 | import ArgumentParser | |
| 2588 | import KeycaskCore | |
| 2589 | ||
| 2590 | struct Find: ParsableCommand { | |
| 2591 | static let configuration = CommandConfiguration(abstract: "Search entries.") | |
| 2592 | ||
| 2593 | @OptionGroup var global: GlobalOptions | |
| 2594 | @Argument(help: "Case-insensitive substring.") var query: String | |
| 2595 | @Flag(name: .long, help: "JSON output.") var json = false | |
| 2596 | ||
| 2597 | func run() throws { | |
| 2598 | let open = try OpenVault.load(global) | |
| 2599 | let entries = open.vault.search(query) | |
| 2600 | if json { | |
| 2601 | print(try Output.json(entries, reveal: false), terminator: "") | |
| 2602 | } else { | |
| 2603 | print(Output.table(entries), terminator: "") | |
| 2604 | } | |
| 2605 | } | |
| 2606 | } | |
| 2607 | ``` | |
| 2608 | ||
| 2609 | Register both: `subcommands: [Init.self, Add.self, Show.self, Ls.self, Find.self]`. | |
| 2610 | ||
| 2611 | - [ ] **Step 4: Run tests** | |
| 2612 | ||
| 2613 | Run: `swift test --filter LsFindTests` | |
| 2614 | Expected: 6 tests pass. | |
| 2615 | ||
| 2616 | - [ ] **Step 5: Lint and commit** | |
| 2617 | ||
| 2618 | ```bash | |
| 2619 | swift format lint --strict --recursive Sources Tests | |
| 2620 | git add Sources/keycask Tests/KeycaskCLITests | |
| 2621 | git commit -m "Add ls and find commands" | |
| 2622 | ``` | |
| 2623 | ||
| 2624 | --- | |
| 2625 | ||
| 2626 | ### Task 12: `edit` and `rm` | |
| 2627 | ||
| 2628 | **Files:** | |
| 2629 | - Create: `Sources/keycask/Commands/Edit.swift` | |
| 2630 | - Create: `Sources/keycask/Commands/Rm.swift` | |
| 2631 | - Modify: `Sources/keycask/Keycask.swift` | |
| 2632 | - Create: `Tests/KeycaskCLITests/EditRmTests.swift` | |
| 2633 | ||
| 2634 | **Interfaces:** | |
| 2635 | - Consumes: `OpenVault`, `Vault.update`, `Vault.remove`, `PasswordOptions`, `PasswordInput`, `Terminal.confirm`, `Terminal.stdinIsTTY`. | |
| 2636 | ||
| 2637 | - [ ] **Step 1: Write the failing tests** | |
| 2638 | ||
| 2639 | ```swift | |
| 2640 | import Foundation | |
| 2641 | import Testing | |
| 2642 | ||
| 2643 | @Suite struct EditRmTests { | |
| 2644 | @Test func editChangesFieldsAndBumpsUpdated() throws { | |
| 2645 | let cli = try CLI.initialized() | |
| 2646 | try cli.run(["add", "gh", "--tag", "a", "--generate"]) | |
| 2647 | let before = try JSONSerialization.jsonObject( | |
| 2648 | with: Data(try cli.run(["show", "gh", "--json"]).stdout.utf8)) as! [String: Any] | |
| 2649 | let r = try cli.run([ | |
| 2650 | "edit", "gh", "--name", "github", "-u", "cmc", "--url", "https://x", "--notes", "n", | |
| 2651 | "--tag", "b", "--untag", "a", | |
| 2652 | ]) | |
| 2653 | #expect(r.status == 0) | |
| 2654 | let after = try JSONSerialization.jsonObject( | |
| 2655 | with: Data(try cli.run(["show", "github", "--json"]).stdout.utf8)) as! [String: Any] | |
| 2656 | #expect(after["name"] as? String == "github") | |
| 2657 | #expect(after["username"] as? String == "cmc") | |
| 2658 | #expect(after["url"] as? String == "https://x") | |
| 2659 | #expect(after["notes"] as? String == "n") | |
| 2660 | #expect(after["tags"] as? [String] == ["b"]) | |
| 2661 | #expect(after["created"] as? String == before["created"] as? String) | |
| 2662 | #expect(after["id"] as? String == before["id"] as? String) | |
| 2663 | } | |
| 2664 | ||
| 2665 | @Test func editPasswordFromStdinAndGenerate() throws { | |
| 2666 | let cli = try CLI.initialized() | |
| 2667 | try cli.run(["add", "gh", "--generate"]) | |
| 2668 | try cli.run(["edit", "gh", "--password"], stdin: "newpass\n") | |
| 2669 | #expect(try cli.run(["show", "gh", "--field", "password"]).stdout == "newpass\n") | |
| 2670 | try cli.run(["edit", "gh", "--generate", "--length", "30"]) | |
| 2671 | #expect(try cli.run(["show", "gh", "--field", "password"]).stdout.count == 31) | |
| 2672 | } | |
| 2673 | ||
| 2674 | @Test func editWithNoChangesIsUsageError() throws { | |
| 2675 | let cli = try CLI.initialized() | |
| 2676 | try cli.run(["add", "gh", "--generate"]) | |
| 2677 | let r = try cli.run(["edit", "gh"]) | |
| 2678 | #expect(r.status == 2) | |
| 2679 | } | |
| 2680 | ||
| 2681 | @Test func editUnknownIsNotFound() throws { | |
| 2682 | let cli = try CLI.initialized() | |
| 2683 | #expect(try cli.run(["edit", "nope", "--url", "x"]).status == 3) | |
| 2684 | } | |
| 2685 | ||
| 2686 | @Test func rmWithYesRemoves() throws { | |
| 2687 | let cli = try CLI.initialized() | |
| 2688 | let id = try cli.run(["add", "gh", "--generate"]).stdout.trimmingCharacters(in: .newlines) | |
| 2689 | let r = try cli.run(["rm", id, "--yes"]) | |
| 2690 | #expect(r.status == 0) | |
| 2691 | #expect(try cli.run(["show", id]).status == 3) | |
| 2692 | #expect(try cli.run(["ls"]).stdout == "") | |
| 2693 | } | |
| 2694 | ||
| 2695 | @Test func rmWithoutYesAndWithoutTTYIsUsageError() throws { | |
| 2696 | let cli = try CLI.initialized() | |
| 2697 | try cli.run(["add", "gh", "--generate"]) | |
| 2698 | let r = try cli.run(["rm", "gh"], stdin: "y\n") | |
| 2699 | #expect(r.status == 2) | |
| 2700 | #expect(r.stderr.contains("--yes")) | |
| 2701 | #expect(try cli.run(["ls"]).lines.count == 1) | |
| 2702 | } | |
| 2703 | ||
| 2704 | @Test func rmAmbiguousNameLists() throws { | |
| 2705 | let cli = try CLI.initialized() | |
| 2706 | try cli.run(["add", "gh", "--generate"]) | |
| 2707 | try cli.run(["add", "gh", "--generate"]) | |
| 2708 | let r = try cli.run(["rm", "gh", "--yes"]) | |
| 2709 | #expect(r.status == 5) | |
| 2710 | #expect(try cli.run(["ls"]).lines.count == 2) | |
| 2711 | } | |
| 2712 | } | |
| 2713 | ``` | |
| 2714 | ||
| 2715 | - [ ] **Step 2: Run tests to verify they fail** | |
| 2716 | ||
| 2717 | Run: `swift test --filter EditRmTests` | |
| 2718 | Expected: failures, unknown subcommand. | |
| 2719 | ||
| 2720 | - [ ] **Step 3: Write Edit.swift** | |
| 2721 | ||
| 2722 | ```swift | |
| 2723 | import ArgumentParser | |
| 2724 | import KeycaskCore | |
| 2725 | ||
| 2726 | struct Edit: ParsableCommand { | |
| 2727 | static let configuration = CommandConfiguration(abstract: "Change an entry.") | |
| 2728 | ||
| 2729 | @OptionGroup var global: GlobalOptions | |
| 2730 | @Argument(help: "Entry id or name.") var ref: String | |
| 2731 | @Option(name: .long, help: "New name.") var name: String? | |
| 2732 | @Option(name: [.short, .customLong("username")], help: "New username.") var username: String? | |
| 2733 | @Option(name: .long, help: "New URL.") var url: String? | |
| 2734 | @Option(name: .long, help: "New notes.") var notes: String? | |
| 2735 | @Option(name: .long, help: "Add a tag. Repeatable.") var tag: [String] = [] | |
| 2736 | @Option(name: .long, help: "Remove a tag. Repeatable.") var untag: [String] = [] | |
| 2737 | @Flag(name: .long, help: "Prompt for a new password.") var password = false | |
| 2738 | @OptionGroup var generated: PasswordOptions | |
| 2739 | ||
| 2740 | mutating func validate() throws { | |
| 2741 | let changes = [name, username, url, notes].contains { $0 != nil } | |
| 2742 | || !tag.isEmpty || !untag.isEmpty || password || generated.generate || generated.words != nil | |
| 2743 | guard changes else { throw ValidationError("nothing to change") } | |
| 2744 | if password, generated.newPassword() != nil { | |
| 2745 | throw ValidationError("--password cannot be combined with --generate or --words") | |
| 2746 | } | |
| 2747 | } | |
| 2748 | ||
| 2749 | func run() throws { | |
| 2750 | var open = try OpenVault.load(global) | |
| 2751 | let target = try open.vault.resolve(ref) | |
| 2752 | let newSecret: String? = | |
| 2753 | password ? try PasswordInput.read(prompt: "New password: ") : generated.newPassword() | |
| 2754 | try open.vault.update(id: target.id) { e in | |
| 2755 | if let name { e.name = name } | |
| 2756 | if let username { e.username = username } | |
| 2757 | if let url { e.url = url } | |
| 2758 | if let notes { e.notes = notes } | |
| 2759 | if let newSecret { e.password = newSecret } | |
| 2760 | let drop = Set(untag.map { $0.lowercased() }) | |
| 2761 | e.tags = e.tags.filter { !drop.contains($0.lowercased()) } + tag | |
| 2762 | } | |
| 2763 | try open.save() | |
| 2764 | } | |
| 2765 | } | |
| 2766 | ``` | |
| 2767 | ||
| 2768 | - [ ] **Step 4: Write Rm.swift** | |
| 2769 | ||
| 2770 | ```swift | |
| 2771 | import ArgumentParser | |
| 2772 | import KeycaskCore | |
| 2773 | ||
| 2774 | struct Rm: ParsableCommand { | |
| 2775 | static let configuration = CommandConfiguration(abstract: "Remove an entry.") | |
| 2776 | ||
| 2777 | @OptionGroup var global: GlobalOptions | |
| 2778 | @Argument(help: "Entry id or name.") var ref: String | |
| 2779 | @Flag(name: .long, help: "Do not ask for confirmation.") var yes = false | |
| 2780 | ||
| 2781 | func run() throws { | |
| 2782 | var open = try OpenVault.load(global) | |
| 2783 | let target = try open.vault.resolve(ref) | |
| 2784 | if !yes { | |
| 2785 | guard Terminal.stdinIsTTY else { | |
| 2786 | throw KeycaskError.usage("refusing to remove without --yes when not on a terminal") | |
| 2787 | } | |
| 2788 | guard Terminal.confirm("remove \(target.name) (\(target.id.rawValue))?") else { | |
| 2789 | throw KeycaskError.failure("aborted") | |
| 2790 | } | |
| 2791 | } | |
| 2792 | try open.vault.remove(id: target.id) | |
| 2793 | try open.save() | |
| 2794 | } | |
| 2795 | } | |
| 2796 | ``` | |
| 2797 | ||
| 2798 | Register: `subcommands: [Init.self, Add.self, Show.self, Ls.self, Find.self, Edit.self, Rm.self]`. | |
| 2799 | ||
| 2800 | - [ ] **Step 5: Run tests** | |
| 2801 | ||
| 2802 | Run: `swift test --filter EditRmTests` | |
| 2803 | Expected: 7 tests pass. | |
| 2804 | ||
| 2805 | - [ ] **Step 6: Lint and commit** | |
| 2806 | ||
| 2807 | ```bash | |
| 2808 | swift format lint --strict --recursive Sources Tests | |
| 2809 | git add Sources/keycask Tests/KeycaskCLITests | |
| 2810 | git commit -m "Add edit and rm commands" | |
| 2811 | ``` | |
| 2812 | ||
| 2813 | --- | |
| 2814 | ||
| 2815 | ### Task 13: `generate` | |
| 2816 | ||
| 2817 | **Files:** | |
| 2818 | - Create: `Sources/keycask/Commands/Generate.swift` | |
| 2819 | - Modify: `Sources/keycask/Keycask.swift` | |
| 2820 | - Create: `Tests/KeycaskCLITests/GenerateTests.swift` | |
| 2821 | ||
| 2822 | **Interfaces:** | |
| 2823 | - Consumes: `Generator`. `--copy` calls `Clipboard.copyWithTimeout`, which does not exist until Task 14; in this task `--copy` is declared but `run()` throws `KeycaskError.failure("clipboard not available")` when it is set. Task 14 replaces that line. | |
| 2824 | ||
| 2825 | - [ ] **Step 1: Write the failing tests** | |
| 2826 | ||
| 2827 | ```swift | |
| 2828 | import Foundation | |
| 2829 | import Testing | |
| 2830 | ||
| 2831 | @Suite struct GenerateTests { | |
| 2832 | @Test func defaultIs24Characters() throws { | |
| 2833 | let cli = try CLI() | |
| 2834 | let r = try cli.run(["generate"], passphrase: nil) | |
| 2835 | #expect(r.status == 0) | |
| 2836 | #expect(r.stdout.count == 25) | |
| 2837 | } | |
| 2838 | ||
| 2839 | @Test func lengthAndWords() throws { | |
| 2840 | let cli = try CLI() | |
| 2841 | #expect(try cli.run(["generate", "--length", "12"], passphrase: nil).stdout.count == 13) | |
| 2842 | let w = try cli.run(["generate", "--words", "6"], passphrase: nil).stdout | |
| 2843 | .trimmingCharacters(in: .newlines).split(separator: "-") | |
| 2844 | #expect(w.count == 6) | |
| 2845 | } | |
| 2846 | ||
| 2847 | @Test func doesNotNeedAVault() throws { | |
| 2848 | let cli = try CLI() | |
| 2849 | #expect(!FileManager.default.fileExists(atPath: cli.vault.path)) | |
| 2850 | #expect(try cli.run(["generate"], passphrase: nil).status == 0) | |
| 2851 | } | |
| 2852 | ||
| 2853 | @Test func lengthAndWordsTogetherIsUsageError() throws { | |
| 2854 | let cli = try CLI() | |
| 2855 | #expect(try cli.run(["generate", "--length", "3", "--words", "3"], passphrase: nil).status == 2) | |
| 2856 | } | |
| 2857 | } | |
| 2858 | ``` | |
| 2859 | ||
| 2860 | - [ ] **Step 2: Run tests to verify they fail** | |
| 2861 | ||
| 2862 | Run: `swift test --filter GenerateTests` | |
| 2863 | Expected: failures, unknown subcommand. | |
| 2864 | ||
| 2865 | - [ ] **Step 3: Write Generate.swift** | |
| 2866 | ||
| 2867 | ```swift | |
| 2868 | import ArgumentParser | |
| 2869 | import KeycaskCore | |
| 2870 | ||
| 2871 | struct Generate: ParsableCommand { | |
| 2872 | static let configuration = CommandConfiguration(abstract: "Generate a password.") | |
| 2873 | ||
| 2874 | @Option(name: .long, help: "Password length (default 24).") var length: Int? | |
| 2875 | @Option(name: .long, help: "Passphrase of this many words instead.") var words: Int? | |
| 2876 | @Flag(name: .long, help: "Copy to the clipboard instead of printing.") var copy = false | |
| 2877 | ||
| 2878 | mutating func validate() throws { | |
| 2879 | if length != nil, words != nil { | |
| 2880 | throw ValidationError("--length and --words are mutually exclusive") | |
| 2881 | } | |
| 2882 | if let length, length < 1 { throw ValidationError("--length must be at least 1") } | |
| 2883 | if let words, words < 1 { throw ValidationError("--words must be at least 1") } | |
| 2884 | } | |
| 2885 | ||
| 2886 | func run() throws { | |
| 2887 | let secret = | |
| 2888 | words.map { Generator.passphrase(words: $0) } | |
| 2889 | ?? Generator.password(length: length ?? Generator.defaultLength) | |
| 2890 | if copy { | |
| 2891 | throw KeycaskError.failure("clipboard not available") | |
| 2892 | } | |
| 2893 | print(secret) | |
| 2894 | } | |
| 2895 | } | |
| 2896 | ``` | |
| 2897 | ||
| 2898 | Register: add `Generate.self` to the subcommand list. | |
| 2899 | ||
| 2900 | - [ ] **Step 4: Run tests** | |
| 2901 | ||
| 2902 | Run: `swift test --filter GenerateTests` | |
| 2903 | Expected: 4 tests pass. | |
| 2904 | ||
| 2905 | - [ ] **Step 5: Lint and commit** | |
| 2906 | ||
| 2907 | ```bash | |
| 2908 | swift format lint --strict --recursive Sources Tests | |
| 2909 | git add Sources/keycask Tests/KeycaskCLITests | |
| 2910 | git commit -m "Add generate command" | |
| 2911 | ``` | |
| 2912 | ||
| 2913 | --- | |
| 2914 | ||
| 2915 | ### Task 14: Clipboard, `clip`, daemon, `generate --copy` | |
| 2916 | ||
| 2917 | **Files:** | |
| 2918 | - Create: `Sources/keycask/Clipboard.swift` | |
| 2919 | - Create: `Sources/keycask/Commands/Clip.swift` | |
| 2920 | - Create: `Sources/keycask/Commands/ClipboardDaemon.swift` | |
| 2921 | - Modify: `Sources/keycask/Commands/Generate.swift` | |
| 2922 | - Modify: `Sources/keycask/Keycask.swift` | |
| 2923 | - Create: `Tests/KeycaskCLITests/ClipboardTests.swift` | |
| 2924 | ||
| 2925 | **Interfaces:** | |
| 2926 | - Produces: | |
| 2927 | ||
| 2928 | ```swift | |
| 2929 | enum Clipboard { | |
| 2930 | struct Handoff: Codable, Equatable { var secret: String; var previous: String } | |
| 2931 | struct Tool { let copy: [String]; let paste: [String] } | |
| 2932 | static let timeoutSeconds = 45 | |
| 2933 | static func shouldRestore(secret: String, current: String?) -> Bool | |
| 2934 | static func findTool(path: String, fileManager: FileManager = .default) -> Tool? | |
| 2935 | static func read() throws -> String | |
| 2936 | static func write(_ text: String) throws | |
| 2937 | static func copyWithTimeout(_ secret: String, seconds: Int = timeoutSeconds) throws | |
| 2938 | static func runDaemon(seconds: Int) throws | |
| 2939 | } | |
| 2940 | ``` | |
| 2941 | ||
| 2942 | The tests never touch the real clipboard. They cover the restore decision, tool discovery against a fake PATH, and the daemon's handoff parsing. | |
| 2943 | ||
| 2944 | - [ ] **Step 1: Write the failing tests** | |
| 2945 | ||
| 2946 | `Tests/KeycaskCLITests/ClipboardTests.swift`: | |
| 2947 | ||
| 2948 | ```swift | |
| 2949 | import Foundation | |
| 2950 | import Testing | |
| 2951 | ||
| 2952 | @testable import keycask | |
| 2953 | ||
| 2954 | @Suite struct ClipboardTests { | |
| 2955 | @Test func restoresOnlyWhenClipboardStillHoldsTheSecret() { | |
| 2956 | #expect(Clipboard.shouldRestore(secret: "s", current: "s")) | |
| 2957 | #expect(!Clipboard.shouldRestore(secret: "s", current: "user pasted")) | |
| 2958 | #expect(!Clipboard.shouldRestore(secret: "s", current: nil)) | |
| 2959 | } | |
| 2960 | ||
| 2961 | @Test func handoffRoundTrips() throws { | |
| 2962 | let h = Clipboard.Handoff(secret: "s3cret", previous: "old") | |
| 2963 | let data = try JSONEncoder().encode(h) | |
| 2964 | #expect(try JSONDecoder().decode(Clipboard.Handoff.self, from: data) == h) | |
| 2965 | } | |
| 2966 | ||
| 2967 | @Test func findToolScansPathInOrder() throws { | |
| 2968 | let dir = FileManager.default.temporaryDirectory | |
| 2969 | .appendingPathComponent("keycask-clip-\(UUID().uuidString)") | |
| 2970 | try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true) | |
| 2971 | #expect(Clipboard.findTool(path: dir.path) == nil) | |
| 2972 | ||
| 2973 | #if os(macOS) | |
| 2974 | let names = ["pbcopy", "pbpaste"] | |
| 2975 | #elseif os(Windows) | |
| 2976 | let names = ["clip.exe", "powershell.exe"] | |
| 2977 | #else | |
| 2978 | let names = ["xclip"] | |
| 2979 | #endif | |
| 2980 | for n in names { | |
| 2981 | let f = dir.appendingPathComponent(n) | |
| 2982 | try Data("#!/bin/sh\n".utf8).write(to: f) | |
| 2983 | try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: f.path) | |
| 2984 | } | |
| 2985 | let tool = Clipboard.findTool(path: dir.path) | |
| 2986 | #expect(tool != nil) | |
| 2987 | #expect(tool?.copy.first?.hasPrefix(dir.path) == true) | |
| 2988 | } | |
| 2989 | ||
| 2990 | @Test func daemonWithoutHandoffFails() throws { | |
| 2991 | let cli = try CLI() | |
| 2992 | let r = try cli.run(["clipboard-daemon", "1"], stdin: "not json", passphrase: nil) | |
| 2993 | #expect(r.status == 1) | |
| 2994 | } | |
| 2995 | ||
| 2996 | @Test func daemonIsHiddenFromHelp() throws { | |
| 2997 | let cli = try CLI() | |
| 2998 | let r = try cli.run(["--help"], passphrase: nil) | |
| 2999 | #expect(!r.stdout.contains("clipboard-daemon")) | |
| 3000 | #expect(r.stdout.contains("clip")) | |
| 3001 | } | |
| 3002 | ||
| 3003 | @Test func clipOfMissingEntryIsNotFoundBeforeTouchingClipboard() throws { | |
| 3004 | let cli = try CLI.initialized() | |
| 3005 | let r = try cli.run(["clip", "nope"]) | |
| 3006 | #expect(r.status == 3) | |
| 3007 | } | |
| 3008 | } | |
| 3009 | ``` | |
| 3010 | ||
| 3011 | - [ ] **Step 2: Run tests to verify they fail** | |
| 3012 | ||
| 3013 | Run: `swift test --filter ClipboardTests` | |
| 3014 | Expected: compile error, `Clipboard` not found. | |
| 3015 | ||
| 3016 | - [ ] **Step 3: Write Clipboard.swift** | |
| 3017 | ||
| 3018 | ```swift | |
| 3019 | import Foundation | |
| 3020 | import KeycaskCore | |
| 3021 | ||
| 3022 | enum Clipboard { | |
| 3023 | struct Handoff: Codable, Equatable { | |
| 3024 | var secret: String | |
| 3025 | var previous: String | |
| 3026 | } | |
| 3027 | ||
| 3028 | struct Tool: Equatable { | |
| 3029 | let copy: [String] | |
| 3030 | let paste: [String] | |
| 3031 | } | |
| 3032 | ||
| 3033 | static let timeoutSeconds = 45 | |
| 3034 | ||
| 3035 | static func shouldRestore(secret: String, current: String?) -> Bool { | |
| 3036 | current == secret | |
| 3037 | } | |
| 3038 | ||
| 3039 | static func findTool( | |
| 3040 | path: String = ProcessInfo.processInfo.environment["PATH"] ?? "", | |
| 3041 | fileManager: FileManager = .default | |
| 3042 | ) -> Tool? { | |
| 3043 | #if os(Windows) | |
| 3044 | let separator: Character = ";" | |
| 3045 | let candidates: [(copy: [String], paste: [String])] = [ | |
| 3046 | (["clip.exe"], ["powershell.exe", "-NoProfile", "-Command", "Get-Clipboard -Raw"]) | |
| 3047 | ] | |
| 3048 | #elseif os(macOS) | |
| 3049 | let separator: Character = ":" | |
| 3050 | let candidates: [(copy: [String], paste: [String])] = [(["pbcopy"], ["pbpaste"])] | |
| 3051 | #else | |
| 3052 | let separator: Character = ":" | |
| 3053 | let candidates: [(copy: [String], paste: [String])] = [ | |
| 3054 | (["wl-copy"], ["wl-paste", "--no-newline"]), | |
| 3055 | (["xclip", "-selection", "clipboard"], ["xclip", "-selection", "clipboard", "-o"]), | |
| 3056 | ] | |
| 3057 | #endif | |
| 3058 | let dirs = path.split(separator: separator).map(String.init) | |
| 3059 | func locate(_ name: String) -> String? { | |
| 3060 | for dir in dirs { | |
| 3061 | let full = URL(fileURLWithPath: dir).appendingPathComponent(name).path | |
| 3062 | if fileManager.isExecutableFile(atPath: full) { return full } | |
| 3063 | } | |
| 3064 | return nil | |
| 3065 | } | |
| 3066 | for candidate in candidates { | |
| 3067 | guard let copy = locate(candidate.copy[0]), let paste = locate(candidate.paste[0]) else { | |
| 3068 | continue | |
| 3069 | } | |
| 3070 | return Tool( | |
| 3071 | copy: [copy] + candidate.copy.dropFirst(), | |
| 3072 | paste: [paste] + candidate.paste.dropFirst()) | |
| 3073 | } | |
| 3074 | return nil | |
| 3075 | } | |
| 3076 | ||
| 3077 | static func read() throws -> String { | |
| 3078 | let tool = try requireTool() | |
| 3079 | let (status, output) = try runTool(tool.paste, input: nil) | |
| 3080 | guard status == 0 else { return "" } | |
| 3081 | return output | |
| 3082 | } | |
| 3083 | ||
| 3084 | static func write(_ text: String) throws { | |
| 3085 | let tool = try requireTool() | |
| 3086 | let (status, _) = try runTool(tool.copy, input: text) | |
| 3087 | guard status == 0 else { throw KeycaskError.failure("clipboard tool failed") } | |
| 3088 | } | |
| 3089 | ||
| 3090 | static func copyWithTimeout(_ secret: String, seconds: Int = timeoutSeconds) throws { | |
| 3091 | _ = try requireTool() | |
| 3092 | let handoff = Handoff(secret: secret, previous: try read()) | |
| 3093 | let process = Process() | |
| 3094 | process.executableURL = Bundle.main.executableURL | |
| 3095 | process.arguments = ["clipboard-daemon", String(seconds)] | |
| 3096 | process.standardOutput = FileHandle.nullDevice | |
| 3097 | process.standardError = FileHandle.nullDevice | |
| 3098 | let input = Pipe() | |
| 3099 | process.standardInput = input | |
| 3100 | do { | |
| 3101 | try process.run() | |
| 3102 | input.fileHandleForWriting.write(try JSONEncoder().encode(handoff)) | |
| 3103 | try input.fileHandleForWriting.close() | |
| 3104 | } catch { | |
| 3105 | throw KeycaskError.failure("start clipboard daemon: \(error)") | |
| 3106 | } | |
| 3107 | } | |
| 3108 | ||
| 3109 | static func runDaemon(seconds: Int) throws { | |
| 3110 | let data = FileHandle.standardInput.readDataToEndOfFile() | |
| 3111 | let handoff: Handoff | |
| 3112 | do { | |
| 3113 | handoff = try JSONDecoder().decode(Handoff.self, from: data) | |
| 3114 | } catch { | |
| 3115 | throw KeycaskError.failure("bad handoff") | |
| 3116 | } | |
| 3117 | try write(handoff.secret) | |
| 3118 | Thread.sleep(forTimeInterval: TimeInterval(seconds)) | |
| 3119 | let current = try? read() | |
| 3120 | guard shouldRestore(secret: handoff.secret, current: current) else { return } | |
| 3121 | try write(handoff.previous) | |
| 3122 | } | |
| 3123 | ||
| 3124 | private static func requireTool() throws -> Tool { | |
| 3125 | guard let tool = findTool() else { | |
| 3126 | #if os(Windows) | |
| 3127 | let hint = "clip.exe and powershell.exe" | |
| 3128 | #elseif os(macOS) | |
| 3129 | let hint = "pbcopy and pbpaste" | |
| 3130 | #else | |
| 3131 | let hint = "wl-clipboard or xclip" | |
| 3132 | #endif | |
| 3133 | throw KeycaskError.failure("no clipboard tool found: install \(hint)") | |
| 3134 | } | |
| 3135 | return tool | |
| 3136 | } | |
| 3137 | ||
| 3138 | private static func runTool(_ argv: [String], input: String?) throws -> (Int32, String) { | |
| 3139 | let process = Process() | |
| 3140 | process.executableURL = URL(fileURLWithPath: argv[0]) | |
| 3141 | process.arguments = Array(argv.dropFirst()) | |
| 3142 | let out = Pipe() | |
| 3143 | process.standardOutput = out | |
| 3144 | process.standardError = FileHandle.nullDevice | |
| 3145 | let inPipe = Pipe() | |
| 3146 | process.standardInput = inPipe | |
| 3147 | do { | |
| 3148 | try process.run() | |
| 3149 | } catch { | |
| 3150 | throw KeycaskError.failure("run \(argv[0]): \(error)") | |
| 3151 | } | |
| 3152 | if let input { inPipe.fileHandleForWriting.write(Data(input.utf8)) } | |
| 3153 | try? inPipe.fileHandleForWriting.close() | |
| 3154 | let data = out.fileHandleForReading.readDataToEndOfFile() | |
| 3155 | process.waitUntilExit() | |
| 3156 | return (process.terminationStatus, String(decoding: data, as: UTF8.self)) | |
| 3157 | } | |
| 3158 | } | |
| 3159 | ``` | |
| 3160 | ||
| 3161 | - [ ] **Step 4: Write Clip.swift and ClipboardDaemon.swift** | |
| 3162 | ||
| 3163 | `Commands/Clip.swift`: | |
| 3164 | ||
| 3165 | ```swift | |
| 3166 | import ArgumentParser | |
| 3167 | import KeycaskCore | |
| 3168 | ||
| 3169 | struct Clip: ParsableCommand { | |
| 3170 | static let configuration = CommandConfiguration( | |
| 3171 | abstract: "Copy a field to the clipboard. Clears after \(Clipboard.timeoutSeconds) seconds.") | |
| 3172 | ||
| 3173 | @OptionGroup var global: GlobalOptions | |
| 3174 | @Argument(help: "Entry id or name.") var ref: String | |
| 3175 | @Option(name: .long, help: "Field to copy (default password).") var field = "password" | |
| 3176 | ||
| 3177 | func run() throws { | |
| 3178 | let open = try OpenVault.load(global) | |
| 3179 | let entry = try open.vault.resolve(ref) | |
| 3180 | let value = try Output.field(entry, named: field) | |
| 3181 | try Clipboard.copyWithTimeout(value) | |
| 3182 | print("copied \(field) of \(entry.name); clears in \(Clipboard.timeoutSeconds)s") | |
| 3183 | } | |
| 3184 | } | |
| 3185 | ``` | |
| 3186 | ||
| 3187 | `Commands/ClipboardDaemon.swift`: | |
| 3188 | ||
| 3189 | ```swift | |
| 3190 | import ArgumentParser | |
| 3191 | ||
| 3192 | struct ClipboardDaemon: ParsableCommand { | |
| 3193 | static let configuration = CommandConfiguration( | |
| 3194 | commandName: "clipboard-daemon", shouldDisplay: false) | |
| 3195 | ||
| 3196 | @Argument var seconds: Int | |
| 3197 | ||
| 3198 | func run() throws { | |
| 3199 | try Clipboard.runDaemon(seconds: seconds) | |
| 3200 | } | |
| 3201 | } | |
| 3202 | ``` | |
| 3203 | ||
| 3204 | In `Generate.swift` replace the `throw KeycaskError.failure("clipboard not available")` line with: | |
| 3205 | ||
| 3206 | ```swift | |
| 3207 | try Clipboard.copyWithTimeout(secret) | |
| 3208 | print("copied; clears in \(Clipboard.timeoutSeconds)s") | |
| 3209 | return | |
| 3210 | ``` | |
| 3211 | ||
| 3212 | Register: `subcommands: [Init.self, Add.self, Show.self, Ls.self, Find.self, Edit.self, Rm.self, Generate.self, Clip.self, ClipboardDaemon.self]`. | |
| 3213 | ||
| 3214 | - [ ] **Step 5: Run tests** | |
| 3215 | ||
| 3216 | Run: `swift test --filter ClipboardTests` | |
| 3217 | Expected: 6 tests pass. | |
| 3218 | ||
| 3219 | - [ ] **Step 6: Manual check on macOS** | |
| 3220 | ||
| 3221 | ```bash | |
| 3222 | swift build && KEYCASK_VAULT=/tmp/kc-manual.kc KEYCASK_PASSPHRASE=pw .build/debug/keycask init | |
| 3223 | KEYCASK_VAULT=/tmp/kc-manual.kc KEYCASK_PASSPHRASE=pw .build/debug/keycask add t --generate | |
| 3224 | KEYCASK_VAULT=/tmp/kc-manual.kc KEYCASK_PASSPHRASE=pw .build/debug/keycask clip t && pbpaste | wc -c | |
| 3225 | sleep 46 && pbpaste | wc -c | |
| 3226 | rm /tmp/kc-manual.kc | |
| 3227 | ``` | |
| 3228 | ||
| 3229 | Expected: first `wc -c` prints 24, second prints the length of whatever was on the clipboard before (0 if it was empty). Record the actual output in the commit message body if it differs. | |
| 3230 | ||
| 3231 | - [ ] **Step 7: Lint and commit** | |
| 3232 | ||
| 3233 | ```bash | |
| 3234 | swift format lint --strict --recursive Sources Tests | |
| 3235 | git add Sources/keycask Tests/KeycaskCLITests | |
| 3236 | git commit -m "Add clipboard support: clip, generate --copy, timed clear" | |
| 3237 | ``` | |
| 3238 | ||
| 3239 | --- | |
| 3240 | ||
| 3241 | ### Task 15: README, full verification, CLI merge request | |
| 3242 | ||
| 3243 | **Files:** | |
| 3244 | - Modify: `README.md` | |
| 3245 | ||
| 3246 | - [ ] **Step 1: Write the README** | |
| 3247 | ||
| 3248 | ````markdown | |
| 3249 | # keycask | |
| 3250 | ||
| 3251 | Command-line password manager. One passphrase-encrypted vault file. | |
| 3252 | Swift, runs on macOS, Linux, and Windows. | |
| 3253 | ||
| 3254 | ## install | |
| 3255 | ||
| 3256 | ```sh | |
| 3257 | swift build -c release | |
| 3258 | cp .build/release/keycask ~/.local/bin/ | |
| 3259 | ``` | |
| 3260 | ||
| 3261 | ## use | |
| 3262 | ||
| 3263 | ```sh | |
| 3264 | keycask init | |
| 3265 | keycask add github -u cmc --url https://github.com --tag dev --generate | |
| 3266 | keycask add mail --words 6 | |
| 3267 | keycask add bank # prompts for the password | |
| 3268 | keycask show github # password masked | |
| 3269 | keycask show github --reveal | |
| 3270 | keycask show github --field password # raw value, for scripts | |
| 3271 | keycask clip github # clipboard, clears after 45s | |
| 3272 | keycask ls --tag dev | |
| 3273 | keycask find example | |
| 3274 | keycask edit github --tag work --untag dev | |
| 3275 | keycask rm github --yes | |
| 3276 | keycask generate --words 5 --copy | |
| 3277 | ``` | |
| 3278 | ||
| 3279 | Every read command takes `--json`. Passwords are masked unless `--reveal`. | |
| 3280 | ||
| 3281 | Names are labels and may repeat. Every command that takes a name also | |
| 3282 | takes the entry's 8-character id, which `ls` and `add` print. An | |
| 3283 | ambiguous name lists the candidates. | |
| 3284 | ||
| 3285 | ## files | |
| 3286 | ||
| 3287 | | what | default | override | | |
| 3288 | |---|---|---| | |
| 3289 | | vault | `~/.local/share/keycask/vault.kc` (`%LOCALAPPDATA%\keycask\vault.kc` on Windows) | `KEYCASK_VAULT`, `--vault` | | |
| 3290 | | passphrase | prompted | `KEYCASK_PASSPHRASE` | | |
| 3291 | ||
| 3292 | The vault is a JSON envelope: PBKDF2-HMAC-SHA256 (600000 rounds) over | |
| 3293 | the passphrase, ChaCha20-Poly1305 over the entries. Writes are atomic. | |
| 3294 | ||
| 3295 | ## exit codes | |
| 3296 | ||
| 3297 | 0 ok, 1 failure, 2 usage, 3 not found, 4 cannot decrypt, 5 ambiguous name. | |
| 3298 | ||
| 3299 | ## develop | |
| 3300 | ||
| 3301 | ```sh | |
| 3302 | swift build | |
| 3303 | swift test | |
| 3304 | swift format lint --strict --recursive Sources Tests | |
| 3305 | ``` | |
| 3306 | ||
| 3307 | Design: `docs/superpowers/specs/2026-09-17-keycask-design.md`. | |
| 3308 | ```` | |
| 3309 | ||
| 3310 | - [ ] **Step 2: Full suite, lint, release build** | |
| 3311 | ||
| 3312 | Run: `swift test && swift format lint --strict --recursive Sources Tests Package.swift && swift build -c release` | |
| 3313 | Expected: all tests pass, no lint output, release binary at `.build/release/keycask`. | |
| 3314 | ||
| 3315 | - [ ] **Step 3: Commit, push, open MR** | |
| 3316 | ||
| 3317 | ```bash | |
| 3318 | git add README.md | |
| 3319 | git commit -m "Write README for the CLI" | |
| 3320 | git push -u origin cli | |
| 3321 | gitbay mr create --source cli --target main --title "CLI: init, add, show, ls, find, edit, rm, generate, clip" --file - <<'EOF' | |
| 3322 | ArgumentParser commands over KeycaskCore. Paths, hidden passphrase prompt, | |
| 3323 | atomic writes, shell-out clipboard with timed clear. Black-box CLI tests | |
| 3324 | cover every command and exit code. | |
| 3325 | EOF | |
| 3326 | ``` | |
| 3327 | ||
| 3328 | - [ ] **Step 4: Wait for CI, merge, clean up** | |
| 3329 | ||
| 3330 | Run `gitbay build list --json` until green. Then: | |
| 3331 | ||
| 3332 | ```bash | |
| 3333 | gitbay mr merge <n> --strategy squash | |
| 3334 | git switch main && git pull && git branch -D cli && git push origin --delete cli | |
| 3335 | ``` | |
| 3336 | ||
| 3337 | Do not merge red. If Linux CI fails on something platform-specific (a `Glibc` import, `posixPermissions`), fix it on the branch and push again. | |