8317e9ec4294056f860132439e32485398ce94c4
[anytun.git] / src / authAlgo.cpp
1 /*
2  *  anytun
3  *
4  *  The secure anycast tunneling protocol (satp) defines a protocol used
5  *  for communication between any combination of unicast and anycast
6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
8  *  ethernet, ip, arp ...). satp directly includes cryptography and
9  *  message authentication based on the methodes used by SRTP.  It is
10  *  intended to deliver a generic, scaleable and secure solution for
11  *  tunneling and relaying of packets of any protocol.
12  *
13  *
14  *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl,
15  *                          Christian Pointner <satp@wirdorange.org>
16  *
17  *  This file is part of Anytun.
18  *
19  *  Anytun is free software: you can redistribute it and/or modify
20  *  it under the terms of the GNU General Public License as published by
21  *  the Free Software Foundation, either version 3 of the License, or
22  *  any later version.
23  *
24  *  Anytun is distributed in the hope that it will be useful,
25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  *  GNU General Public License for more details.
28  *
29  *  You should have received a copy of the GNU General Public License
30  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
31  */
32
33 #include "authAlgo.h"
34 #include "log.h"
35 #include "anytunError.h"
36 #include "buffer.h"
37 #include "encryptedPacket.h"
38
39 #include <iostream>
40 #include <cstring>
41
42 //****** NullAuthAlgo ******
43 void NullAuthAlgo::generate(KeyDerivation& kd, EncryptedPacket& packet)
44 {
45 }
46
47 bool NullAuthAlgo::checkTag(KeyDerivation& kd, EncryptedPacket& packet)
48 {
49   return true;
50 }
51
52 #ifndef NO_CRYPT
53 //****** Sha1AuthAlgo ******
54
55 Sha1AuthAlgo::Sha1AuthAlgo(kd_dir_t d) : AuthAlgo(d), key_(DIGEST_LENGTH)
56 {
57 #ifndef USE_SSL_CRYPTO
58   gcry_error_t err = gcry_md_open(&handle_, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
59   if(err) {
60     cLog.msg(Log::PRIO_ERROR) << "Sha1AuthAlgo::Sha1AuthAlgo: Failed to open message digest algo";
61     return;
62   }
63 #else
64   HMAC_CTX_init(&ctx_);
65   HMAC_Init_ex(&ctx_, NULL, 0, EVP_sha1(), NULL);
66 #endif
67 }
68
69 Sha1AuthAlgo::~Sha1AuthAlgo()
70 {
71 #ifndef USE_SSL_CRYPTO
72   if(handle_) {
73     gcry_md_close(handle_);
74   }
75 #else
76   HMAC_CTX_cleanup(&ctx_);
77 #endif
78 }
79
80 void Sha1AuthAlgo::generate(KeyDerivation& kd, EncryptedPacket& packet)
81 {
82 #ifndef USE_SSL_CRYPTO
83   if(!handle_) {
84     return;
85   }
86 #endif
87
88   packet.addAuthTag();
89   if(!packet.getAuthTagLength()) {
90     return;
91   }
92
93   kd.generate(dir_, LABEL_AUTH, packet.getSeqNr(), key_);
94 #ifndef USE_SSL_CRYPTO
95   gcry_error_t err = gcry_md_setkey(handle_, key_.getBuf(), key_.getLength());
96   if(err) {
97     cLog.msg(Log::PRIO_ERROR) << "Sha1AuthAlgo::setKey: Failed to set hmac key: " << AnytunGpgError(err);
98     return;
99   }
100
101   gcry_md_reset(handle_);
102   gcry_md_write(handle_, packet.getAuthenticatedPortion(), packet.getAuthenticatedPortionLength());
103   gcry_md_final(handle_);
104   uint8_t* hmac = gcry_md_read(handle_, 0);
105 #else
106   HMAC_Init_ex(&ctx_, key_.getBuf(), key_.getLength(), EVP_sha1(), NULL);
107
108   uint8_t hmac[DIGEST_LENGTH];
109   HMAC_Update(&ctx_, packet.getAuthenticatedPortion(), packet.getAuthenticatedPortionLength());
110   HMAC_Final(&ctx_, hmac, NULL);
111 #endif
112
113   uint8_t* tag = packet.getAuthTag();
114   uint32_t length = (packet.getAuthTagLength() < DIGEST_LENGTH) ? packet.getAuthTagLength() : DIGEST_LENGTH;
115
116   if(length > DIGEST_LENGTH) {
117     std::memset(tag, 0, packet.getAuthTagLength());
118   }
119
120   std::memcpy(&tag[packet.getAuthTagLength() - length], &hmac[DIGEST_LENGTH - length], length);
121 }
122
123 bool Sha1AuthAlgo::checkTag(KeyDerivation& kd, EncryptedPacket& packet)
124 {
125 #ifndef USE_SSL_CRYPTO
126   if(!handle_) {
127     return false;
128   }
129 #endif
130
131   packet.withAuthTag(true);
132   if(!packet.getAuthTagLength()) {
133     return true;
134   }
135
136   kd.generate(dir_, LABEL_AUTH, packet.getSeqNr(), key_);
137 #ifndef USE_SSL_CRYPTO
138   gcry_error_t err = gcry_md_setkey(handle_, key_.getBuf(), key_.getLength());
139   if(err) {
140     cLog.msg(Log::PRIO_ERROR) << "Sha1AuthAlgo::setKey: Failed to set hmac key: " << AnytunGpgError(err);
141     return false;
142   }
143
144   gcry_md_reset(handle_);
145   gcry_md_write(handle_, packet.getAuthenticatedPortion(), packet.getAuthenticatedPortionLength());
146   gcry_md_final(handle_);
147   uint8_t* hmac = gcry_md_read(handle_, 0);
148 #else
149   HMAC_Init_ex(&ctx_, key_.getBuf(), key_.getLength(), EVP_sha1(), NULL);
150
151   uint8_t hmac[DIGEST_LENGTH];
152   HMAC_Update(&ctx_, packet.getAuthenticatedPortion(), packet.getAuthenticatedPortionLength());
153   HMAC_Final(&ctx_, hmac, NULL);
154 #endif
155
156   uint8_t* tag = packet.getAuthTag();
157   uint32_t length = (packet.getAuthTagLength() < DIGEST_LENGTH) ? packet.getAuthTagLength() : DIGEST_LENGTH;
158
159   if(length > DIGEST_LENGTH)
160     for(uint32_t i=0; i < (packet.getAuthTagLength() - DIGEST_LENGTH); ++i)
161       if(tag[i]) { return false; }
162
163   int ret = std::memcmp(&tag[packet.getAuthTagLength() - length], &hmac[DIGEST_LENGTH - length], length);
164   packet.removeAuthTag();
165
166   if(ret) {\r
167     return false;\r
168   }\r
169 \r
170   return true;
171 }
172
173 #endif