unit-tests/test_key.cpp

   1 /*
   2  *  Copyright (c) 2017 - 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  */
  16
  17 #include <string>
  18
  19 #include <boost_macros_wrapper.h>
  20 #include <test_common.h>
  21
  22 #include <key-impl.h>
  23 #include <key-aes-impl.h>
  24 #include <data-type.h>
  25
  26 using namespace CKM;
  27
  28 namespace {
  29
  30 constexpr char PASS[] = "password";
  31
  32 struct KeyData {
  33         KeyType type;
  34         bool pass;
  35         std::string data;
  36 };
  37
  38 const KeyData KEYS[] = {
  39         {
  40                 KeyType::KEY_RSA_PRIVATE,
  41                 false,
  42                 "-----BEGIN RSA PRIVATE KEY-----\n"
  43                 "MIICXAIBAAKBgQDMP6sKttnQ58BAi27b8X+8KVQtJgpJhhCF0RtWaTVqAhVDG3y4\n"
  44                 "x6IuAvXDtPSjLe/2E01fYGVxNComPJOmUOfUD06BCWPYH2+7jOfQIOy/TMlt+W7x\n"
  45                 "fou9rqnPRoKRaodoLqH5WK0ahkntWCAjstoKZoG+3Op0tEjy0jpmzeyNiQIDAQAB\n"
  46                 "AoGBAJRDX1CuvNx1bkwsKvQDkTqwMYd4hp0qcVICIbsPMhPaoT6OdHHZkHOf+HDx\n"
  47                 "KWhOj1LsXgzu95Q+Tp5k+LURI8ayu2RTsz/gYECgPNUsZ7gXl4co1bK+g5kiC+qr\n"
  48                 "sgSfkbYpp0OXefnl5x4KaJlZeSpn0UdDqx0kwI1x2E098i1VAkEA5thNY9YZNQdN\n"
  49                 "p6aopxOF5OmAjbLkq6wu255rDM5YgeepXXro/lmPociobtv8vPzbWKfoYZJL0Zj4\n"
  50                 "Qzj7Qz7s0wJBAOKBbpeG9PuNP1nR1h8kvyuILW8F89JOcIOUeqwokq4eJVqXdFIj\n"
  51                 "ct8eSEFmyXNqXD7b9+Tcw6vRIZuddVhNcrMCQAlpaD5ZzE1NLu1W7ilhsmPS4Vrl\n"
  52                 "oE0fiAmMO/EZuKITP+R/zmAQZrrB45whe/x4krjan67auByjj/utpxDmz+ECQEg/\n"
  53                 "UK80dN/n5dUYgVvdtLyF6zgGhgcGzgyqR5ayOlcfdnq25Htuoy1X02RJDOirfFDw\n"
  54                 "iNmPMTqUskuYpd1MltECQBwcy1cpnJWIXwCTQwg3enjkOVw80Tbr3iU9ASjHJTH2\n"
  55                 "N6FGHC4BQCm1fL6Bo0/0oSra+Ika3/1Vw1WwijUSiO8=\n"
  56                 "-----END RSA PRIVATE KEY-----"
  57         },{
  58                 KeyType::KEY_RSA_PRIVATE,
  59                 true,
  60                 "-----BEGIN RSA PRIVATE KEY-----\n"
  61                 "Proc-Type: 4,ENCRYPTED\n"
  62                 "DEK-Info: AES-128-CBC,C73D912AE0B2F3AE9DDF4E4ACBA904A6\n"
  63                 "\n"
  64                 "Q4jKICSZm6cNDavb1WFWJTKfqyr+XYkXTfpVVtMcJ/34dcLxzqxOzigjiSR7RfeN\n"
  65                 "0JQHUKJgUHz5eCg4uCwaEBE+WkWzwREsD34bY73fLqqSL9Dpx5/6eHvXNI/zcueP\n"
  66                 "SZphgUpV4xSUPnlZ3M39NUaDmHmGccdInmsd8AB+StuT/2M2hVUgFQiYKL6XcyFt\n"
  67                 "xsARQo0IfeSgUV5M7gwxJkwbdlEzENPpRLif8g1yVDGMUefoNiC46mxlvADq9Lt6\n"
  68                 "fI1FVH5yMeADgTXcW/YJ/1wIY3RspDOXZQK/RlNxjt3KOGUL1h7dD3a4R+8Xwjxi\n"
  69                 "lk1m8HDFZc35PBBNkEL0qGtRzlWuU1Gpsef4MAJpm6VsdCXDXoeu8be4EsKUXNif\n"
  70                 "8DyBqaTYmqg6TD3ZtHFqmRq+mv6dYUYBLA6BJvfPwDagUmkju8maXet/fQ+8Xse/\n"
  71                 "zZFl59pz5jm6d9fxRI+5eWaw6b7gD7nREgpbgToaJHbWw2yrVHkhEs37gtS9DR3O\n"
  72                 "+a4eOMJMwAspI/RK3K+4QND6ffmCbJH8hroz4PtbBb2war4C+SLN7XoOhcQQK5tU\n"
  73                 "WBVuJR4CharlRwG5hO7wIBWAdwgpv5IZ/SM9D561ktHLnAhCp66RCjcmAmy7dGVq\n"
  74                 "KX2g0Iu7yGGALDbdmznrkt6TeaPrSXd3Kn6qZCYLWV8i/XpDknelii2mqlrztPog\n"
  75                 "K04bvdDXX80vtLyGiG+kmteaT45+nhrl22siOaokxQuiCuZax6pXKFLJDr1n1KIi\n"
  76                 "O8eHDDfjNrxdjA23KJmfzMbHU+/G65jBomeS6opwMrVfD/ee0rlVCBQxCiNRrnlx\n"
  77                 "-----END RSA PRIVATE KEY-----\n"
  78         },{
  79                 KeyType::KEY_RSA_PUBLIC,
  80                 false,
  81                 "-----BEGIN PUBLIC KEY-----\n"
  82                 "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMP6sKttnQ58BAi27b8X+8KVQt\n"
  83                 "JgpJhhCF0RtWaTVqAhVDG3y4x6IuAvXDtPSjLe/2E01fYGVxNComPJOmUOfUD06B\n"
  84                 "CWPYH2+7jOfQIOy/TMlt+W7xfou9rqnPRoKRaodoLqH5WK0ahkntWCAjstoKZoG+\n"
  85                 "3Op0tEjy0jpmzeyNiQIDAQAB\n"
  86                 "-----END PUBLIC KEY-----"
  87         },{
  88                 KeyType::KEY_DSA_PRIVATE,
  89                 false,
  90                 "-----BEGIN DSA PRIVATE KEY-----\n"
  91                 "MIIBuwIBAAKBgQDIsQRYgnU4mm5VrMyykpNNzeHTQAO8E2hJAcOwNPBrdos8amak\n"
  92                 "rcJnyBaNh56ZslcuXNEKJuxiDsy4VM9KUR8fHTqTiF5s+4NArzdrdwNQpKWjAqJN\n"
  93                 "fgpCdaLZHw9o857flcQ4dyYNnAz1/SNGnv03Dm8EYRNRFNaFNw7zBPjyVwIVANyj\n"
  94                 "7ijLfrCbDZDi6ond5Np1Ns0hAoGBAIcS1ceWtw6DAGmYww27r/1lLtqjrq8j0w0a\n"
  95                 "F6Ly+pZ/y+WTw9KT18eRKPmVgruVSn3VVVJeN00XaoKvfPSHkTRIE5rro2ZEInhp\n"
  96                 "3g0Vak7EXJWe7KKBRXqSMNFkndjKv1nyNKeWSEq9Xql6SPn8J8TfmbyUpPSIglZR\n"
  97                 "vJ2DHwHJAoGAPZLRdIhIIJi4UWoyQrCqk1iF3pkBeukXzeZGqNWEjgzLAjMZEVYM\n"
  98                 "DLLKippahjxLZSWB7LOoS+XE4fonpBBute/tgF23ToR8fQuiBu+KvtAP/QuCOJ/L\n"
  99                 "S0aYYr1/eXmMByYPZ58Vf93KuUgoUAkWmc+mLBn6J2+fygnWcOOSo6sCFC/slPOv\n"
 100                 "yAKPlW7WQzgV5jLLNUW7\n"
 101                 "-----END DSA PRIVATE KEY-----"
 102         },{
 103                 KeyType::KEY_DSA_PRIVATE,
 104                 true,
 105                 "-----BEGIN DSA PRIVATE KEY-----\n"
 106                 "Proc-Type: 4,ENCRYPTED\n"
 107                 "DEK-Info: AES-128-CBC,048C0CDD71CF9AF8D647C364365C44F1\n"
 108                 "\n"
 109                 "lBUAm8XCQ0xoa7P3s8VCRK8Dw0oqDlk2P1Yr9oQZ4zq7eEz4ozocOeANLEsarTrT\n"
 110                 "IaxrZnuGs+lg6NqEk3UdHCvocJr4TP+jommMYYXCZcX7l0D/CjqJZ/EWb8xrvVqN\n"
 111                 "Ra+JuZQobFnhDJLC0eHzhuNSZJe2OViEnWEyv3cYvztekzY7ldR3A5MhLScXJ9fZ\n"
 112                 "Ufabu5ZbJNsNdcZp/kVE6piriANqy2CECGKp7BycVjHRGE44+jpI5TrXoxuaPUsR\n"
 113                 "cFvaeWRdhUHGjuxiSaDjSn3LR6UenpfYDFKPl5h6TLKcHZLx1kjtiN+Fed4Y7Xzb\n"
 114                 "Va8OMj/g7AsJmzrl4+qdfgTz0SnbbLAXTpHMg7DBJDM6eNDgXsOeLHoJp4t+50vQ\n"
 115                 "M4qCmhoUZ5cMiTUpbGQMqwawXORe0JM+Qg/6jdWHnH5zdyYxbqk7wIhPAGMm0Gbd\n"
 116                 "6bXHutc+AaMVIdqoBvhppeedEUNFVSkoxyglJY3fb24n81Us/r1IUwWL4exWLXsl\n"
 117                 "DizasdaCWN43k45BJ+It9L6RcKJLwCQpppfPcZBPCavYh4wW93NXVsbpPesDyXwX\n"
 118                 "87h4JnKOgH5wtt/xforC+g==\n"
 119                 "-----END DSA PRIVATE KEY-----\n"
 120         },{
 121                 KeyType::KEY_DSA_PUBLIC,
 122                 false,
 123                 "-----BEGIN PUBLIC KEY-----\n"
 124                 "MIIBtzCCASwGByqGSM44BAEwggEfAoGBAMixBFiCdTiablWszLKSk03N4dNAA7wT\n"
 125                 "aEkBw7A08Gt2izxqZqStwmfIFo2HnpmyVy5c0Qom7GIOzLhUz0pRHx8dOpOIXmz7\n"
 126                 "g0CvN2t3A1CkpaMCok1+CkJ1otkfD2jznt+VxDh3Jg2cDPX9I0ae/TcObwRhE1EU\n"
 127                 "1oU3DvME+PJXAhUA3KPuKMt+sJsNkOLqid3k2nU2zSECgYEAhxLVx5a3DoMAaZjD\n"
 128                 "Dbuv/WUu2qOuryPTDRoXovL6ln/L5ZPD0pPXx5Eo+ZWCu5VKfdVVUl43TRdqgq98\n"
 129                 "9IeRNEgTmuujZkQieGneDRVqTsRclZ7sooFFepIw0WSd2Mq/WfI0p5ZISr1eqXpI\n"
 130                 "+fwnxN+ZvJSk9IiCVlG8nYMfAckDgYQAAoGAPZLRdIhIIJi4UWoyQrCqk1iF3pkB\n"
 131                 "eukXzeZGqNWEjgzLAjMZEVYMDLLKippahjxLZSWB7LOoS+XE4fonpBBute/tgF23\n"
 132                 "ToR8fQuiBu+KvtAP/QuCOJ/LS0aYYr1/eXmMByYPZ58Vf93KuUgoUAkWmc+mLBn6\n"
 133                 "J2+fygnWcOOSo6s=\n"
 134                 "-----END PUBLIC KEY-----"
 135         },{
 136                 KeyType::KEY_ECDSA_PRIVATE,
 137                 false,
 138                 "-----BEGIN EC PRIVATE KEY-----\n"
 139                 "MF8CAQEEGF3rz8OuFpcESrlqCm0G96oovr0XbX+DRKAKBggqhkjOPQMBAaE0AzIA\n"
 140                 "BHiZYByQiRNQ91GWNnTfoBbp9G8DP9oJYc/cDZlk4lKUpmbvm//RWf1U7ag3tOVy\n"
 141                 "sQ==\n"
 142                 "-----END EC PRIVATE KEY-----"
 143         },{
 144                 KeyType::KEY_ECDSA_PRIVATE,
 145                 true,
 146                 "-----BEGIN EC PRIVATE KEY-----\n"
 147                 "Proc-Type: 4,ENCRYPTED\n"
 148                 "DEK-Info: AES-128-CBC,F9C394444D857C605B9F12265A7F5530\n"
 149                 "\n"
 150                 "D5k5JXXUFNytJVxhTOotRRE2/J8Ur9hSMYkIil2uQszpxRD8Pay8GsIEjiO7hi4S\n"
 151                 "fn2CdmrqKuX7xOa5uaD3hn0fZzKrSASfhKVBb153nWF4r7tvwAa9gIs3dK9379xC\n"
 152                 "3zZhim3HX6gG9WXdwC4rHRkglEGTMFTf1Okr9A8Uu+hYv2yAd8b8kumLwhXw6vMC\n"
 153                 "rIH/GTe6jp4l2xEkdBFQ//Xyd/xEmMxP+28mMKEb6tSiLbN2glBxuj6FWgEYZNJS\n"
 154                 "BVcctKSvXJY4MpsWxso73CFWZJPeOZ/lNicYkPRsGfU=\n"
 155                 "-----END EC PRIVATE KEY-----"
 156         },{
 157                 KeyType::KEY_ECDSA_PUBLIC,
 158                 false,
 159                 "-----BEGIN PUBLIC KEY-----\n"
 160                 "MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEeJlgHJCJE1D3UZY2dN+gFun0bwM/\n"
 161                 "2glhz9wNmWTiUpSmZu+b/9FZ/VTtqDe05XKx\n"
 162                 "-----END PUBLIC KEY-----"
 163         }
 164 };
 165
 166 void requireKey(const Key& key, KeyType type, int size)
 167 {
 168         BOOST_REQUIRE(!key.empty());
 169         BOOST_REQUIRE(key.getType() == type);
 170         BOOST_REQUIRE(!key.getDER().empty());
 171         BOOST_REQUIRE(key.getSize() == size);
 172 }
 173
 174 void requireKeyImpl(const KeyImpl& key, KeyType type)
 175 {
 176         requireKey(key, type, 0);
 177
 178         BOOST_REQUIRE(key.getEvpShPtr());
 179
 180         if (DataType(type).isKeyPrivate()) {
 181                 BOOST_REQUIRE(key.getDER() == key.getDERPRV());
 182                 BOOST_REQUIRE(!key.getDERPRV().empty());
 183         } else {
 184                 BOOST_REQUIRE(key.getDER() == key.getDERPUB());
 185         }
 186 }
 187
 188 void requireNoKey(const Key& key)
 189 {
 190         BOOST_REQUIRE(key.empty());
 191         BOOST_REQUIRE(key.getType() == KeyType::KEY_NONE);
 192         BOOST_REQUIRE(key.getDER().empty());
 193         BOOST_REQUIRE(key.getSize() == 0);
 194 }
 195
 196 void requireNoKeyImpl(const KeyImpl& key)
 197 {
 198         requireNoKey(key);
 199         BOOST_REQUIRE(!key.getEvpShPtr());
 200         BOOST_REQUIRE(key.getDERPRV().empty());
 201         BOOST_REQUIRE(key.getDERPUB().empty());
 202 }
 203
 204 KeyType privateType(KeyType type)
 205 {
 206         switch (type)
 207         {
 208         case KeyType::KEY_RSA_PUBLIC:
 209                 return KeyType::KEY_RSA_PRIVATE;
 210         case KeyType::KEY_DSA_PUBLIC:
 211                 return KeyType::KEY_DSA_PRIVATE;
 212         case KeyType::KEY_ECDSA_PUBLIC:
 213                 return KeyType::KEY_ECDSA_PRIVATE;
 214         default:
 215                 return type;
 216         }
 217 }
 218
 219 } // anonymous namespace
 220
 221 BOOST_AUTO_TEST_SUITE(KEY_TEST)
 222
 223 POSITIVE_TEST_CASE(KeyImpl)
 224 {
 225         for (auto& keyInfo : KEYS) {
 226                 RawBuffer keyBuf(keyInfo.data.begin(), keyInfo.data.end());
 227
 228                 // PEM
 229                 KeyImpl keyPem(keyBuf, keyInfo.pass ? PASS : "");
 230                 requireKeyImpl(keyPem, keyInfo.type);
 231
 232                 // DER
 233                 KeyImpl keyDer(keyPem.getDER());
 234                 requireKeyImpl(keyDer, keyInfo.type);
 235
 236                 // EVP
 237                 KeyImpl keyEvp(keyPem.getEvpShPtr(), keyInfo.type);
 238                 requireKeyImpl(keyEvp, keyInfo.type);
 239
 240                 // KeyShPtr
 241                 auto keyPtr = Key::create(keyBuf, keyInfo.pass ? PASS : "");
 242                 BOOST_REQUIRE(keyPtr);
 243                 requireKey(*keyPtr, keyInfo.type, 0);
 244         }
 245 }
 246
 247 NEGATIVE_TEST_CASE(KeyImpl)
 248 {
 249         // PEM empty buffer
 250         requireNoKeyImpl(KeyImpl(RawBuffer()));
 251
 252         auto keyPtr = Key::create(RawBuffer());
 253         BOOST_REQUIRE(!keyPtr);
 254
 255         for (auto& keyInfo : KEYS) {
 256                 RawBuffer keyBuf(keyInfo.data.begin(), keyInfo.data.end());
 257
 258                 // PEM
 259                 if (keyInfo.pass)
 260                         requireNoKeyImpl(KeyImpl(keyBuf, "wrong password"));
 261                 auto keyBuf2 = keyBuf;
 262                 keyBuf2.resize(keyBuf.size() - 2);
 263                 requireNoKeyImpl(KeyImpl(keyBuf2, keyInfo.pass ? PASS : ""));
 264                 KeyImpl keyPem(keyBuf, keyInfo.pass ? PASS : "");
 265
 266                 // DER
 267                 auto der = keyPem.getDER();
 268                 der.resize(der.size() - 1);
 269                 KeyImpl keyDer(der);
 270                 requireNoKeyImpl(keyDer);
 271
 272                 // EVP
 273                 requireNoKeyImpl(KeyImpl(KeyImpl::EvpShPtr(), keyInfo.type));
 274                 for (int i = -1; i <= static_cast<int>(KeyType::KEY_AES) + 1; i++) {
 275                         KeyType otherType = static_cast<KeyType>(i);
 276                         if (privateType(otherType) == privateType(keyInfo.type))
 277                                 continue;
 278
 279                         requireNoKeyImpl(KeyImpl(keyPem.getEvpShPtr(), otherType));
 280                 }
 281
 282                 // KeyShPtr
 283                 if (keyInfo.pass)
 284                         BOOST_REQUIRE(!Key::create(keyBuf, ""));
 285         }
 286 }
 287
 288 POSITIVE_TEST_CASE(KeyAesImpl)
 289 {
 290         auto testAes = [](size_t size){
 291                 auto keyBuf = createRandom(size);
 292                 auto key = Key::createAES(keyBuf);
 293                 BOOST_REQUIRE(key);
 294                 requireKey(*key, KeyType::KEY_AES, size);
 295                 BOOST_REQUIRE(key->getDER() == keyBuf);
 296         };
 297
 298         testAes(32);
 299         testAes(24);
 300         testAes(16);
 301 }
 302
 303 NEGATIVE_TEST_CASE(KeyAesImpl)
 304 {
 305         auto testNoAes = [](size_t size){
 306                 auto keyBuf = createRandom(size);
 307                 auto key = Key::createAES(keyBuf);
 308                 BOOST_REQUIRE(!key);
 309                 requireNoKey(KeyAESImpl(keyBuf));
 310         };
 311
 312         testNoAes(0);
 313         testNoAes(1);
 314         testNoAes(8);
 315         testNoAes(15);
 316         testNoAes(17);
 317         testNoAes(33);
 318         testNoAes(48);
 319         testNoAes(64);
 320 }
 321
 322 BOOST_AUTO_TEST_SUITE_END()