adulau/ssldump
1
0
Fork 0
mirror of https://github.com/adulau/ssldump.git synced 2024-11-22 01:17:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #83 from wllm-rbnt/lint

Browse source 
Global code linting + various fixes
This commit is contained in:
Alexandre Dulaunoy 2023-08-14 22:08:48 +02:00 committed by GitHub
commit e1796a8851
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
96 changed files with 8504 additions and 15176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

183
.clang-format Normal file
View file

@ -0,0 +1,183 @@
---
Language: Cpp
# BasedOnStyle: Chromium
# with a few modifications
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveBitFields: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: false
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
SortPriority: 0
- Regex: '^<.*\.h>'
Priority: 1
SortPriority: 0
- Regex: '^<.*'
Priority: 2
SortPriority: 0
- Regex: '.*'
Priority: 3
SortPriority: 0
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: true
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentWidth: 2
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Right
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
- ParseTestProto
- ParsePartialTestProto
CanonicalDelimiter: ''
BasedOnStyle: google
ReflowComments: true
SortIncludes: false
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: Never
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Auto
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseCRLF: false
UseTab: Never
WhitespaceSensitiveMacros:
- STRINGIZE
- PP_STRINGIZE
- BOOST_PP_STRINGIZE
...

2
CMakeLists.txt
View file

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.16.3) cmake_minimum_required(VERSION 3.13.4)
include(CheckSymbolExists) include(CheckSymbolExists)
project( project(

9
FILES
View file

@ -1,9 +0,0 @@
record-fmt.txt
record_analyze.c
record_analyze.h
targets.mk
CVS:
Entries
Repository
Root

2
README.md
View file

@ -29,7 +29,7 @@ For more details, check the man page.
This example will query ja3er.com service to display the known ja3 hashes from the TLS handshaked in the pcap. This example will query ja3er.com service to display the known ja3 hashes from the TLS handshaked in the pcap.
`ssldump -r yourcapture.pcap -j | jq -r 'select(.ja3_fp != null) | .ja3_fp' | parallel 'curl -s -X GET 'https://ja3er.com/search/{}' | jq .'` `./ssldump -r yourcapture.pcap -j | jq -r 'select(.ja3_fp != null) | .ja3_fp' | parallel 'curl -s -X GET 'https://ja3er.com/search/{}' | jq .'`
# Why do you maintain this repository? # Why do you maintain this repository?

439
base/network.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: network.c,v 1.10 2002/09/09 21:02:58 ekr Exp $ $Id: network.c,v 1.10 2002/09/09 21:02:58 ekr Exp $
@ -43,8 +44,6 @@
ekr@rtfm.com Tue Dec 29 09:52:54 1998 ekr@rtfm.com Tue Dec 29 09:52:54 1998
*/ */
#include <sys/types.h> #include <sys/types.h>
#include <r_common.h> #include <r_common.h>
#include "network.h" #include "network.h"
@ -64,259 +63,251 @@
UINT4 NET_print_flags; UINT4 NET_print_flags;
struct network_handler_ { struct network_handler_ {
proto_mod *mod; proto_mod *mod;
proto_ctx *ctx; proto_ctx *ctx;
}; };
int network_handler_create(mod,handlerp) int network_handler_create(proto_mod *mod, n_handler **handlerp) {
proto_mod *mod; int r, _status;
n_handler **handlerp; n_handler *handler = 0;
{
int r,_status;
n_handler *handler=0;
if(!(handler=(n_handler *)malloc(sizeof(n_handler)))) if(!(handler = (n_handler *)malloc(sizeof(n_handler))))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
if(mod->vtbl->create_ctx){ if(mod->vtbl->create_ctx) {
if((r=mod->vtbl->create_ctx(mod->handle,&handler->ctx))) if((r = mod->vtbl->create_ctx(mod->handle, &handler->ctx)))
ABORT(r); ABORT(r);
} }
handler->mod=mod; handler->mod = mod;
*handlerp=handler; *handlerp = handler;
_status=0; _status = 0;
abort: abort:
if(_status){ if(_status) {
network_handler_destroy(mod, &handler); network_handler_destroy(mod, &handler);
} }
return(_status); return (_status);
}
int network_handler_destroy(proto_mod *mod, n_handler **handlerp) {
n_handler *handler = 0;
if(!handlerp || !*handlerp)
return (0);
handler = *handlerp;
mod->vtbl->destroy_ctx(mod->handle, &handler->ctx);
free(*handlerp);
*handlerp = 0;
return (0);
}
int network_process_packet(n_handler *handler,
struct timeval *timestamp,
UCHAR *data,
int length,
int af) {
int r;
int hlen;
packet p;
u_short off;
int proto;
/*We can pretty much ignore all the options*/
memcpy(&p.ts, timestamp, sizeof(struct timeval));
p.base = data;
p._len = length;
p.data = data;
p.len = length;
p.af = af;
if(p.len < 20) {
if(!(NET_print_flags & NET_PRINT_JSON))
printf(
"Malformed packet, packet too small to contain IP header, skipping "
"...\n");
return (0);
} }
int network_handler_destroy(mod,handlerp) memset(&p.i_addr.so_st, 0x0, sizeof(struct sockaddr_storage));
proto_mod *mod; memset(&p.r_addr.so_st, 0x0, sizeof(struct sockaddr_storage));
n_handler **handlerp;
{
n_handler *handler=0;
if(!handlerp || !*handlerp)
return(0);
handler = *handlerp; if(af == AF_INET) {
p.l3_hdr.ip = (struct ip *)data;
memcpy(&p.i_addr.so_in.sin_addr, &p.l3_hdr.ip->ip_src,
sizeof(struct in_addr));
p.i_addr.so_in.sin_family = AF_INET;
memcpy(&p.r_addr.so_in.sin_addr, &p.l3_hdr.ip->ip_dst,
sizeof(struct in_addr));
p.r_addr.so_in.sin_family = AF_INET;
mod->vtbl->destroy_ctx(mod->handle,&handler->ctx); /*Handle, or rather mishandle, fragmentation*/
free(*handlerp); off = ntohs(p.l3_hdr.ip->ip_off);
*handlerp=0;
return(0);
}
int network_process_packet(handler,timestamp,data,length,af) if((off & 0x1fff) || /*Later fragment*/
n_handler *handler; (off & 0x2000)) { /*More fragments*/
struct timeval *timestamp; /* fprintf(stderr,"Fragmented packet! rejecting\n"); */
UCHAR *data; return (0);
int length; }
int af;
{
int r;
int hlen;
packet p;
u_short off;
int proto;
/*We can pretty much ignore all the options*/ hlen = p.l3_hdr.ip->ip_hl * 4;
memcpy(&p.ts,timestamp,sizeof(struct timeval)); p.data += hlen;
p.base=data; p.len = ntohs(p.l3_hdr.ip->ip_len);
p._len=length;
p.data=data;
p.len=length;
p.af=af;
if(p.len < 20) { if(p.len > length) {
if(!(NET_print_flags & NET_PRINT_JSON)) if(!(NET_print_flags & NET_PRINT_JSON))
printf("Malformed packet, packet too small to contain IP header, skipping ...\n"); printf(
return(0); "Malformed packet, size from IP header is larger than size "
"reported by libpcap, skipping ...\n");
return (0);
} }
memset(&p.i_addr.so_st, 0x0, sizeof(struct sockaddr_storage)); if(p.len == 0) {
memset(&p.r_addr.so_st, 0x0, sizeof(struct sockaddr_storage)); DBG((0,
"ip length reported as 0, presumed to be because of 'TCP "
"segmentation offload' (TSO)\n"));
p.len = p._len;
}
p.len -= hlen;
if(af == AF_INET) { proto = p.l3_hdr.ip->ip_p;
p.l3_hdr.ip=(struct ip *)data; } else {
memcpy(&p.i_addr.so_in.sin_addr, &p.l3_hdr.ip->ip_src, sizeof(struct in_addr)); p.l3_hdr.ip6 = (struct ip6_hdr *)data;
p.i_addr.so_in.sin_family = AF_INET; memcpy(&p.i_addr.so_in6.sin6_addr, &p.l3_hdr.ip6->ip6_src,
memcpy(&p.r_addr.so_in.sin_addr, &p.l3_hdr.ip->ip_dst, sizeof(struct in_addr)); sizeof(struct in6_addr));
p.r_addr.so_in.sin_family = AF_INET; p.i_addr.so_in6.sin6_family = AF_INET6;
memcpy(&p.r_addr.so_in6.sin6_addr, &p.l3_hdr.ip6->ip6_dst,
/*Handle, or rather mishandle, fragmentation*/ sizeof(struct in6_addr));
off=ntohs(p.l3_hdr.ip->ip_off); p.r_addr.so_in6.sin6_family = AF_INET6;
// Skip packets with header extensions
if((off & 0x1fff) || /*Later fragment*/ if(p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP) {
(off & 0x2000)){ /*More fragments*/ return 0;
/* fprintf(stderr,"Fragmented packet! rejecting\n"); */
return(0);
}
hlen=p.l3_hdr.ip->ip_hl * 4;
p.data += hlen;
p.len = ntohs(p.l3_hdr.ip->ip_len);
if(p.len > length) {
if(!(NET_print_flags & NET_PRINT_JSON))
printf("Malformed packet, size from IP header is larger than size reported by libpcap, skipping ...\n");
return(0);
}
if (p.len == 0) {
DBG((0,"ip length reported as 0, presumed to be because of 'TCP segmentation offload' (TSO)\n"));
p.len = p._len;
}
p.len -= hlen;
proto = p.l3_hdr.ip->ip_p;
} else {
p.l3_hdr.ip6=(struct ip6_hdr *)data;
memcpy(&p.i_addr.so_in6.sin6_addr, &p.l3_hdr.ip6->ip6_src, sizeof(struct in6_addr));
p.i_addr.so_in6.sin6_family = AF_INET6;
memcpy(&p.r_addr.so_in6.sin6_addr, &p.l3_hdr.ip6->ip6_dst, sizeof(struct in6_addr));
p.r_addr.so_in6.sin6_family = AF_INET6;
// Skip packets with header extensions
if(p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP) {
return 0;
}
hlen=40; // Fixed header size with no extension
p.data += hlen;
p.len = ntohs(p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
if(p.len > length) {
if(!(NET_print_flags & NET_PRINT_JSON))
printf("Malformed packet, size from IP header is larger than size reported by libpcap, skipping ...\n");
return(0);
}
if (p.len == 0) {
DBG((0,"ip length reported as 0, presumed to be because of 'TCP segmentation offload' (TSO)\n"));
p.len = p._len;
}
proto = p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
} }
switch(proto){ hlen = 40; // Fixed header size with no extension
case IPPROTO_TCP: p.data += hlen;
if((r=process_tcp_packet(handler->mod,handler->ctx,&p))) p.len = ntohs(p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
ERETURN(r); if(p.len > length) {
break; if(!(NET_print_flags & NET_PRINT_JSON))
printf(
"Malformed packet, size from IP header is larger than size "
"reported by libpcap, skipping ...\n");
return (0);
} }
return(0); if(p.len == 0) {
DBG((0,
"ip length reported as 0, presumed to be because of 'TCP "
"segmentation offload' (TSO)\n"));
p.len = p._len;
}
proto = p.l3_hdr.ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
} }
int packet_copy(in,out) switch(proto) {
packet *in; case IPPROTO_TCP:
packet **out; if((r = process_tcp_packet(handler->mod, handler->ctx, &p)))
{ ERETURN(r);
int _status; break;
packet *p=0;
if(!(p=(packet *)calloc(1,sizeof(packet))))
ABORT(R_NO_MEMORY);
memcpy(&p->ts,&in->ts,sizeof(struct timeval));
if(!(p->base=(UCHAR *)malloc(in->_len)))
ABORT(R_NO_MEMORY);
memcpy(p->base,in->base,p->_len=in->_len);
p->data=p->base + (in->data - in->base);
p->len=in->len;
p->ip=(struct ip *)(p->base + ((UCHAR *)in->ip - in->base));
p->tcp=(struct tcphdr *)(p->base + ((UCHAR *)in->tcp - in->base));
*out=p;
_status=0;
abort:
if(_status){
packet_destroy(p);
}
return(_status);
} }
int packet_destroy(p) return (0);
packet *p; }
{
if(!p)
return(0);
FREE(p->base); int packet_copy(packet *in, packet **out) {
FREE(p); int _status;
return(0);
packet *p = 0;
if(!(p = (packet *)calloc(1, sizeof(packet))))
ABORT(R_NO_MEMORY);
memcpy(&p->ts, &in->ts, sizeof(struct timeval));
if(!(p->base = (UCHAR *)malloc(in->_len)))
ABORT(R_NO_MEMORY);
memcpy(p->base, in->base, p->_len = in->_len);
p->data = p->base + (in->data - in->base);
p->len = in->len;
p->ip = (struct ip *)(p->base + ((UCHAR *)in->ip - in->base));
p->tcp = (struct tcphdr *)(p->base + ((UCHAR *)in->tcp - in->base));
*out = p;
_status = 0;
abort:
if(_status) {
packet_destroy(p);
}
return (_status);
}
int packet_destroy(packet *p) {
if(!p)
return (0);
FREE(p->base);
FREE(p);
return (0);
}
int timestamp_diff(struct timeval *t1,
struct timeval *t0,
struct timeval *diff) {
long d;
if(t0->tv_sec > t1->tv_sec)
ERETURN(R_BAD_ARGS);
/*Easy case*/
if(t0->tv_usec <= t1->tv_usec) {
diff->tv_sec = t1->tv_sec - t0->tv_sec;
diff->tv_usec = t1->tv_usec - t0->tv_usec;
return (0);
} }
int timestamp_diff(t1,t0,diff) /*Hard case*/
struct timeval *t1; d = t0->tv_usec - t1->tv_usec;
struct timeval *t0; if(t1->tv_sec < (t0->tv_sec + 1))
struct timeval *diff; ERETURN(R_BAD_ARGS);
{ diff->tv_sec = t1->tv_sec - (t0->tv_sec + 1);
long d; diff->tv_usec = 1000000 - d;
if(t0->tv_sec > t1->tv_sec) return (0);
ERETURN(R_BAD_ARGS); }
/*Easy case*/ int lookuphostname(struct sockaddr_storage *so_st, char **namep) {
if(t0->tv_usec <= t1->tv_usec){ int r = 1;
diff->tv_sec=t1->tv_sec - t0->tv_sec; *namep = calloc(1, NI_MAXHOST);
diff->tv_usec=t1->tv_usec - t0->tv_usec; void *addr = NULL;
return(0);
}
/*Hard case*/ if(!(NET_print_flags & NET_PRINT_NO_RESOLVE)) {
d=t0->tv_usec - t1->tv_usec; r = getnameinfo((struct sockaddr *)so_st, sizeof(struct sockaddr_storage),
if(t1->tv_sec < (t0->tv_sec + 1)) *namep, NI_MAXHOST, NULL, 0, 0);
ERETURN(R_BAD_ARGS);
diff->tv_sec=t1->tv_sec - (t0->tv_sec + 1);
diff->tv_usec=1000000 - d;
return(0);
} }
if(r) {
int lookuphostname(so_st,namep)
struct sockaddr_storage *so_st;
char **namep;
{
int r = 1;
*namep = calloc(1, NI_MAXHOST);
void *addr = NULL;
if(!(NET_print_flags & NET_PRINT_NO_RESOLVE)) {
r = getnameinfo((struct sockaddr *) so_st, sizeof(struct sockaddr_storage), *namep, NI_MAXHOST, NULL, 0, 0);
}
if(r) {
if(so_st->ss_family == AF_INET) {
addr = &((struct sockaddr_in *) so_st)->sin_addr;
} else {
addr = &((struct sockaddr_in6 *) so_st)->sin6_addr;
}
inet_ntop(so_st->ss_family, addr, *namep, INET6_ADDRSTRLEN);
}
return(0);
}
int addrtotext(so_st,namep)
struct sockaddr_storage *so_st;
char **namep;
{
*namep = calloc(1, NI_MAXHOST);
void *addr = NULL;
if(so_st->ss_family == AF_INET) { if(so_st->ss_family == AF_INET) {
addr = &((struct sockaddr_in *) so_st)->sin_addr; addr = &((struct sockaddr_in *)so_st)->sin_addr;
} else { } else {
addr = &((struct sockaddr_in6 *) so_st)->sin6_addr; addr = &((struct sockaddr_in6 *)so_st)->sin6_addr;
} }
inet_ntop(so_st->ss_family, addr, *namep, INET6_ADDRSTRLEN); inet_ntop(so_st->ss_family, addr, *namep, INET6_ADDRSTRLEN);
return(0);
} }
return (0);
}
int addrtotext(struct sockaddr_storage *so_st, char **namep) {
*namep = calloc(1, NI_MAXHOST);
void *addr = NULL;
if(so_st->ss_family == AF_INET) {
addr = &((struct sockaddr_in *)so_st)->sin_addr;
} else {
addr = &((struct sockaddr_in6 *)so_st)->sin6_addr;
}
inet_ntop(so_st->ss_family, addr, *namep, INET6_ADDRSTRLEN);
return (0);
}

90
base/network.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: network.h,v 1.3 2001/09/14 22:29:14 ekr Exp $ $Id: network.h,v 1.3 2001/09/14 22:29:14 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Tue Dec 29 09:53:50 1998 ekr@rtfm.com Tue Dec 29 09:53:50 1998
*/ */
#ifndef _network_h #ifndef _network_h
#define _network_h #define _network_h
@ -74,44 +74,47 @@ typedef struct proto_mod_ proto_mod;
typedef struct proto_handler_ proto_handler; typedef struct proto_handler_ proto_handler;
typedef struct packet_ packet; typedef struct packet_ packet;
int network_handler_create PROTO_LIST((proto_mod *mod, int network_handler_create PROTO_LIST((proto_mod * mod, n_handler **handlerp));
n_handler **handlerp)); int network_handler_destroy PROTO_LIST((proto_mod * mod, n_handler **handlerp));
int network_handler_destroy PROTO_LIST((proto_mod *mod,n_handler **handlerp)); int network_process_packet PROTO_LIST((n_handler * handler,
int network_process_packet PROTO_LIST((n_handler *handler, struct timeval *timestamp,
struct timeval *timestamp,UCHAR *data,int length,int af)); UCHAR *data,
int packet_copy PROTO_LIST((packet *in,packet **out)); int length,
int packet_destroy PROTO_LIST((packet *p)); int af));
int timestamp_diff PROTO_LIST(( struct timeval *t1,struct timeval *t0, int packet_copy PROTO_LIST((packet * in, packet **out));
struct timeval *diff)); int packet_destroy PROTO_LIST((packet * p));
int lookuphostname PROTO_LIST((struct sockaddr_storage *addr,char **name)); int timestamp_diff PROTO_LIST((struct timeval * t1,
int addrtotext PROTO_LIST((struct sockaddr_storage *addr,char **name)); struct timeval *t0,
struct timeval *diff));
int lookuphostname PROTO_LIST((struct sockaddr_storage * addr, char **name));
int addrtotext PROTO_LIST((struct sockaddr_storage * addr, char **name));
struct packet_ { struct packet_ {
struct timeval ts; struct timeval ts;
UCHAR *base; /*The base of the packet*/ UCHAR *base; /*The base of the packet*/
int _len; int _len;
UCHAR *data; /*The data ptr appropriate to this layer*/ UCHAR *data; /*The data ptr appropriate to this layer*/
int len; /*The length of the data segment*/ int len; /*The length of the data segment*/
/*These just save us the effort of doing casts to the data /*These just save us the effort of doing casts to the data
segments*/ segments*/
struct ip *ip; /*The IP header*/ struct ip *ip; /*The IP header*/
int af; int af;
union { union {
struct ip *ip; /*The IP header*/ struct ip *ip; /*The IP header*/
struct ip6_hdr *ip6; /*The IP header*/ struct ip6_hdr *ip6; /*The IP header*/
} l3_hdr; } l3_hdr;
struct tcphdr *tcp; /*The TCP header*/ struct tcphdr *tcp; /*The TCP header*/
union { union {
struct sockaddr_storage so_st; struct sockaddr_storage so_st;
struct sockaddr_in so_in; struct sockaddr_in so_in;
struct sockaddr_in6 so_in6; struct sockaddr_in6 so_in6;
} i_addr; } i_addr;
union { union {
struct sockaddr_storage so_st; struct sockaddr_storage so_st;
struct sockaddr_in so_in; struct sockaddr_in so_in;
struct sockaddr_in6 so_in6; struct sockaddr_in6 so_in6;
} r_addr; } r_addr;
}; };
#include "tcpconn.h" #include "tcpconn.h"
@ -119,11 +122,10 @@ struct packet_ {
extern UINT4 NET_print_flags; extern UINT4 NET_print_flags;
#define NET_PRINT_TCP_HDR 1 #define NET_PRINT_TCP_HDR 1
#define NET_PRINT_TYPESET 2 #define NET_PRINT_TYPESET 2
#define NET_PRINT_ACKS 4 #define NET_PRINT_ACKS 4
#define NET_PRINT_NO_RESOLVE 8 #define NET_PRINT_NO_RESOLVE 8
#define NET_PRINT_JSON 16 #define NET_PRINT_JSON 16
#define NET_PRINT_TS 32 #define NET_PRINT_TS 32
#endif #endif

807
base/pcap-snoop.c.in
View file

@ -46,9 +46,6 @@
ekr@rtfm.com Tue Dec 29 10:17:41 1998 ekr@rtfm.com Tue Dec 29 10:17:41 1998
*/ */
#include <pcap.h> #include <pcap.h>
#include <unistd.h> #include <unistd.h>
#ifndef __OpenBSD__ #ifndef __OpenBSD__
@ -80,497 +77,491 @@
#include "pcap_logger.h" #include "pcap_logger.h"
#ifndef ETHERTYPE_8021Q #ifndef ETHERTYPE_8021Q
# define ETHERTYPE_8021Q 0x8100 #define ETHERTYPE_8021Q 0x8100
#endif #endif
char *collapse_args PROTO_LIST((int argc,char **argv)); char *collapse_args PROTO_LIST((int argc, char **argv));
static int pcap_if_type=DLT_NULL; static int pcap_if_type = DLT_NULL;
int err_exit PROTO_LIST((char *str,int num)); int err_exit PROTO_LIST((char *str, int num));
int usage PROTO_LIST((void)); int usage PROTO_LIST((void));
int print_version PROTO_LIST((void)); int print_version PROTO_LIST((void));
void sig_handler PROTO_LIST((int sig)); void sig_handler PROTO_LIST((int sig));
void pcap_cb PROTO_LIST((u_char *ptr,const struct pcap_pkthdr *hdr,const u_char *data)); void pcap_cb PROTO_LIST((u_char * ptr,
int main PROTO_LIST((int argc,char **argv)); const struct pcap_pkthdr *hdr,
const u_char *data));
int main PROTO_LIST((int argc, char **argv));
int packet_cnt = 0; // Packet counter used for connection pool cleaning int packet_cnt = 0; // Packet counter used for connection pool cleaning
int conn_freq = 100; // Number of packets after which a connection pool int conn_freq = 100; // Number of packets after which a connection pool
// cleaning is performed // cleaning is performed
int conn_ttl = 100; // TTL of inactive connections in connection pool int conn_ttl = 100; // TTL of inactive connections in connection pool
struct timeval last_packet_seen_time = // Timestamp of the last packet of the struct timeval last_packet_seen_time = // Timestamp of the last packet of the
(struct timeval) {0}; // last block of conn_freq packets seen (struct timeval){0}; // last block of conn_freq packets seen
logger_mod *logger=NULL; logger_mod *logger = NULL;
int err_exit(str,num) int err_exit(char *str, int num) {
char *str; fprintf(stderr, "ERROR: %s\n", str);
int num; sig_handler(SIGQUIT);
{ exit(num);
fprintf(stderr,"ERROR: %s\n",str); }
sig_handler(SIGQUIT);
exit(num);
}
int usage() int usage(void) {
{ fprintf(stderr,
fprintf(stderr,"Usage: ssldump [-r dumpfile] [-i interface] [-l sslkeylogfile] [-w outpcapfile]\n"); "Usage: ssldump [-r dumpfile] [-i interface] [-l sslkeylogfile] [-w "
fprintf(stderr," [-k keyfile] [-p password] [-vtaTznsAxVNde]\n"); "outpcapfile]\n");
fprintf(stderr," [filter]\n"); fprintf(stderr,
exit(0); " [-k keyfile] [-p password] [-vtaTznsAxVNde]\n");
} fprintf(stderr, " [filter]\n");
exit(0);
}
int print_version() int print_version(void) {
{ printf("Version: @ssldump_VERSION@ (@ssldump_DESCRIPTION@)\n");
printf("Version: @ssldump_VERSION@ (@ssldump_DESCRIPTION@)\n"); printf(
printf("Maintained by a bunch of volunteers, see https://github.com/adulau/ssldump/blob/master/CREDITS\n"); "Maintained by a bunch of volunteers, see "
printf("Copyright (C) 2015-2023 the aforementioned volunteers\n"); "https://github.com/adulau/ssldump/blob/master/CREDITS\n");
printf("Copyright (C) 1998-2001 RTFM, Inc.\n"); printf("Copyright (C) 2015-2023 the aforementioned volunteers\n");
printf("All rights reserved.\n"); printf("Copyright (C) 1998-2001 RTFM, Inc.\n");
printf("All rights reserved.\n");
#ifdef OPENSSL #ifdef OPENSSL
printf("Compiled with OpenSSL: decryption enabled\n"); printf("Compiled with OpenSSL: decryption enabled\n");
#endif #endif
exit(0); exit(0);
} }
pcap_t *p; pcap_t *p;
proto_mod *mod=&ssl_mod; proto_mod *mod = &ssl_mod;
n_handler *n; n_handler *n;
char *interface_name=0; char *interface_name = 0;
char *file=0; char *file = 0;
char *filter=0; char *filter = 0;
void sig_handler(int sig) void sig_handler(int sig) {
{ int freed_conn = 0;
int freed_conn = 0; fflush(stdout);
fflush(stdout); if(logger)
if (logger) logger->vtbl->deinit();
logger->vtbl->deinit();
freed_conn = destroy_all_conn(); freed_conn = destroy_all_conn();
if(freed_conn && !(NET_print_flags & NET_PRINT_JSON)) if(freed_conn && !(NET_print_flags & NET_PRINT_JSON))
printf("Cleaned %d remaining connection(s) from connection pool\n", freed_conn); printf("Cleaned %d remaining connection(s) from connection pool\n",
freed_conn);
network_handler_destroy(mod, &n); network_handler_destroy(mod, &n);
if(p) if(p)
pcap_close(p); pcap_close(p);
if(interface_name) if(interface_name)
free(interface_name); free(interface_name);
if(filter) if(filter)
free(filter); free(filter);
if(file) if(file)
free(file); free(file);
exit(sig); exit(sig);
} }
void pcap_cb(ptr,hdr,data) void pcap_cb(u_char *ptr, const struct pcap_pkthdr *hdr, const u_char *data) {
u_char *ptr; n_handler *n;
const struct pcap_pkthdr *hdr; int len;
const u_char *data; struct ether_header *e_hdr = (struct ether_header *)data;
{ int type, cleaned_conn;
n_handler *n;
int len;
struct ether_header *e_hdr=(struct ether_header *)data;
int type, cleaned_conn;
n=(n_handler *)ptr; n = (n_handler *)ptr;
if(hdr->caplen!=hdr->len) err_exit("Length mismatch",-1); if(hdr->caplen != hdr->len)
err_exit("Length mismatch", -1);
len=hdr->len; len = hdr->len;
switch(pcap_if_type){ switch(pcap_if_type) {
case DLT_RAW: case DLT_RAW:
#ifdef DLT_LOOP #ifdef DLT_LOOP
case DLT_LOOP: case DLT_LOOP:
#endif #endif
case DLT_NULL: case DLT_NULL:
data+=4; data += 4;
len-=4; len -= 4;
break; break;
case DLT_EN10MB: case DLT_EN10MB:
if(len < sizeof(struct ether_header)) { if(len < sizeof(struct ether_header)) {
if(!(NET_print_flags & NET_PRINT_JSON)) if(!(NET_print_flags & NET_PRINT_JSON))
printf("Frame size too small to contain Ethernet header, skipping ...\n"); printf(
return; "Frame size too small to contain Ethernet header, skipping "
} "...\n");
return;
}
type=ntohs(e_hdr->ether_type); type = ntohs(e_hdr->ether_type);
data+=sizeof(struct ether_header); data += sizeof(struct ether_header);
len-=sizeof(struct ether_header); len -= sizeof(struct ether_header);
/* if vlans, push past VLAN header (4 bytes) */ /* if vlans, push past VLAN header (4 bytes) */
if(type==ETHERTYPE_8021Q) { if(type == ETHERTYPE_8021Q) {
type=ntohs(*(u_int16_t *)(data + 2)); type = ntohs(*(u_int16_t *)(data + 2));
data+=4; data += 4;
len+=4; len += 4;
} }
if(type!=ETHERTYPE_IP && type!=ETHERTYPE_IPV6) if(type != ETHERTYPE_IP && type != ETHERTYPE_IPV6)
return; return;
break; break;
case DLT_IEEE802: case DLT_IEEE802:
data+=22; data += 22;
len-=22; len -= 22;
break; break;
case DLT_FDDI: case DLT_FDDI:
data+=21; data += 21;
len-=21; len -= 21;
break; break;
#ifdef __amigaos__ #ifdef __amigaos__
case DLT_MIAMI: case DLT_MIAMI:
data+=16; data += 16;
len-=16; len -= 16;
break; break;
#endif #endif
case DLT_SLIP: case DLT_SLIP:
#ifdef DLT_SLIP_BSDOS #ifdef DLT_SLIP_BSDOS
case DLT_SLIP_BSDOS: case DLT_SLIP_BSDOS:
#endif #endif
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__) || defined(__APPLE__) #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || \
data+=16; defined(__bsdi__) || defined(__APPLE__)
len-=16; data += 16;
len -= 16;
#else #else
data+=24; data += 24;
len-=24; len -= 24;
#endif #endif
break; break;
case DLT_PPP: case DLT_PPP:
#ifdef DLT_PPP_BSDOS #ifdef DLT_PPP_BSDOS
case DLT_PPP_BSDOS: case DLT_PPP_BSDOS:
#endif #endif
#ifdef DLT_PPP_SERIAL #ifdef DLT_PPP_SERIAL
case DLT_PPP_SERIAL: case DLT_PPP_SERIAL:
#endif #endif
#ifdef DLT_PPP_ETHER #ifdef DLT_PPP_ETHER
case DLT_PPP_ETHER: case DLT_PPP_ETHER:
#endif #endif
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__) || defined(__APPLE__) #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || \
data+=4; defined(__bsdi__) || defined(__APPLE__)
len-=4; data += 4;
len -= 4;
#else #else
#if defined(sun) || defined(__sun) #if defined(sun) || defined(__sun)
data+=8; data += 8;
len-=8; len -= 8;
#else #else
data+=24; data += 24;
len-=24; len -= 24;
#endif #endif
#endif #endif
break; break;
#ifdef DLT_ENC #ifdef DLT_ENC
case DLT_ENC: case DLT_ENC:
data+=12; data += 12;
len-=12; len -= 12;
break; break;
#endif #endif
#ifdef DLT_LINUX_SLL #ifdef DLT_LINUX_SLL
case DLT_LINUX_SLL: case DLT_LINUX_SLL:
data+=16; data += 16;
len-=16; len -= 16;
break; break;
#endif #endif
#ifdef DLT_IPNET #ifdef DLT_IPNET
case DLT_IPNET: case DLT_IPNET:
data+=24; data += 24;
len-=24; len -= 24;
break; break;
#endif #endif
}
if(type == ETHERTYPE_IPV6)
network_process_packet(n,(struct timeval *) &hdr->ts,(u_char *)data,len, AF_INET6);
else
network_process_packet(n,(struct timeval *) &hdr->ts,(u_char *)data,len, AF_INET);
if(packet_cnt == conn_freq) {
packet_cnt = 0;
memcpy(&last_packet_seen_time,&hdr->ts,sizeof(struct timeval));
if((cleaned_conn = clean_old_conn()) && !(NET_print_flags & NET_PRINT_JSON))
printf("%d inactive connection(s) cleaned from connection pool\n", cleaned_conn);
} else {
packet_cnt++;
}
} }
if(type == ETHERTYPE_IPV6)
network_process_packet(n, (struct timeval *)&hdr->ts, (u_char *)data, len,
AF_INET6);
else
network_process_packet(n, (struct timeval *)&hdr->ts, (u_char *)data, len,
AF_INET);
if(packet_cnt == conn_freq) {
packet_cnt = 0;
memcpy(&last_packet_seen_time, &hdr->ts, sizeof(struct timeval));
if((cleaned_conn = clean_old_conn()) && !(NET_print_flags & NET_PRINT_JSON))
printf("%d inactive connection(s) cleaned from connection pool\n",
cleaned_conn);
} else {
packet_cnt++;
}
}
typedef struct module_def_ { typedef struct module_def_ {
char *name; char *name;
proto_mod *mod; proto_mod *mod;
} module_def; } module_def;
static module_def modules[]={ static module_def modules[] = {{"SSL", &ssl_mod},
{"SSL",&ssl_mod}, {"NULL", &null_mod},
{"NULL",&null_mod},
#ifdef ENABLE_RECORD #ifdef ENABLE_RECORD
{"RECORD",&record_mod}, {"RECORD", &record_mod},
#endif #endif
{0,0} {0, 0}};
};
int parse_ssl_flag PROTO_LIST((int c)); int parse_ssl_flag PROTO_LIST((int c));
int main(argc,argv) int main(int argc, char **argv) {
int argc; int r;
char **argv;
{
int r;
#ifdef _WIN32 #ifdef _WIN32
__declspec(dllimport) char *optarg; __declspec(dllimport) char *optarg;
__declspec(dllimport) int optind; __declspec(dllimport) int optind;
#else #else
extern char *optarg; extern char *optarg;
extern int optind; extern int optind;
#endif #endif
pcap_if_t *interfaces; pcap_if_t *interfaces;
bpf_u_int32 localnet,netmask; bpf_u_int32 localnet, netmask;
int c; int c;
module_def *m=0; module_def *m = 0;
int no_promiscuous=0; int no_promiscuous = 0;
int freed_conn=0; int freed_conn = 0;
char errbuf[PCAP_ERRBUF_SIZE]; char errbuf[PCAP_ERRBUF_SIZE];
signal(SIGINT,sig_handler); signal(SIGINT, sig_handler);
while((c=getopt(argc,argv,"vr:F:f:S:jyTt:ai:k:l:w:p:znsAxXhHVNdqem:P"))!=EOF){ while((c = getopt(argc, argv, "vr:F:f:S:jyTt:ai:k:l:w:p:znsAxXhHVNdqem:P")) !=
switch(c){ EOF) {
case 'v': switch(c) {
print_version(); case 'v':
break; print_version();
case 'f': break;
fprintf(stderr,"-f option replaced by -r. Use that in the future\n"); case 'f':
case 'r': fprintf(stderr, "-f option replaced by -r. Use that in the future\n");
file=strdup(optarg); case 'r':
break; file = strdup(optarg);
case 'S': break;
ssl_mod.vtbl->parse_flags(optarg); case 'S':
break; ssl_mod.vtbl->parse_flags(optarg);
case 'y': break;
NET_print_flags|=NET_PRINT_TYPESET; case 'y':
/*Kludge*/ NET_print_flags |= NET_PRINT_TYPESET;
SSL_print_flags |= SSL_PRINT_NROFF; /*Kludge*/
break; SSL_print_flags |= SSL_PRINT_NROFF;
case 'j': break;
NET_print_flags |= NET_PRINT_JSON; case 'j':
SSL_print_flags |= SSL_PRINT_JSON; NET_print_flags |= NET_PRINT_JSON;
break; SSL_print_flags |= SSL_PRINT_JSON;
case 'z': break;
NET_print_flags |= NET_PRINT_TS; case 'z':
break; NET_print_flags |= NET_PRINT_TS;
case 'a': break;
NET_print_flags |= NET_PRINT_ACKS; case 'a':
break; NET_print_flags |= NET_PRINT_ACKS;
case 'A': break;
SSL_print_flags |= SSL_PRINT_ALL_FIELDS; case 'A':
break; SSL_print_flags |= SSL_PRINT_ALL_FIELDS;
case 'T': break;
NET_print_flags |= NET_PRINT_TCP_HDR; case 'T':
break; NET_print_flags |= NET_PRINT_TCP_HDR;
case 'i': break;
interface_name=strdup(optarg); case 'i':
break; interface_name = strdup(optarg);
case 'k': break;
SSL_keyfile=strdup(optarg); case 'k':
break; SSL_keyfile = strdup(optarg);
case 'l': break;
SSL_keylogfile=strdup(optarg); case 'l':
break; SSL_keylogfile = strdup(optarg);
case 'w': break;
logger=&pcap_mod; case 'w':
if(logger->vtbl->init(optarg)!=0){ logger = &pcap_mod;
fprintf(stderr,"Can not open/create out pcap %s\n", if(logger->vtbl->init(optarg) != 0) {
optarg); fprintf(stderr, "Can not open/create out pcap %s\n", optarg);
exit(1);
}
break;
case 'p':
SSL_password=strdup(optarg);
break;
case 'P':
++no_promiscuous;
break;
case 'n':
NET_print_flags |= NET_PRINT_NO_RESOLVE;
break;
case 't':
conn_ttl=atoi(optarg);
break;
case 'F':
conn_freq=atoi(optarg);
break;
case 'm':
for(m=modules;m->name!=0;m++){
if(!strcmp(m->name,optarg)){
mod=m->mod;
break;
}
}
if(!m->name){
fprintf(stderr,"Request analysis module %s not found\n",
optarg);
exit(1);
}
break;
case 'h':
usage();
printf("Do 'man ssldump' for documentation\n");
exit(1); exit(1);
case '?':
usage();
exit(1);
/* must be an SSL flag. This is kind of a gross
special case */
default:
parse_ssl_flag(c);
break;
}
}
argv+=optind;
argc-=optind;
if(!file){
if(!interface_name){
if(pcap_findalldevs(&interfaces,errbuf)==-1) {
fprintf(stderr,"PCAP: %s\n",errbuf);
err_exit("Aborting",-1);
} }
interface_name=interfaces->name; break;
if(!interface_name){ case 'p':
fprintf(stderr,"PCAP: %s\n",errbuf); SSL_password = strdup(optarg);
err_exit("Aborting",-1); break;
} case 'P':
} ++no_promiscuous;
if(!(p=pcap_open_live(interface_name,65535,!no_promiscuous,1000,errbuf))){ break;
fprintf(stderr,"PCAP: %s\n",errbuf); case 'n':
err_exit("Aborting",-1); NET_print_flags |= NET_PRINT_NO_RESOLVE;
} break;
case 't':
if (pcap_lookupnet(interface_name, &localnet, &netmask, errbuf) < 0) conn_ttl = atoi(optarg);
fprintf(stderr,"PCAP: %s\n", errbuf); break;
} case 'F':
else{ conn_freq = atoi(optarg);
if(!(p=pcap_open_offline(file,errbuf))){ break;
fprintf(stderr,"PCAP: %s\n",errbuf); case 'm':
err_exit("Aborting",-1); for(m = modules; m->name != 0; m++) {
} if(!strcmp(m->name, optarg)) {
mod = m->mod;
netmask=0; break;
localnet=0;
}
if(argc!=0)
filter=collapse_args(argc,argv);
if(filter){
struct bpf_program fp;
/* (F5 patch)
* reformat filter to include traffic with or without the 802.1q
* vlan header. for example, "port 80" becomes:
* "( port 80 ) or ( vlan and port 80 )".
* note that if the filter includes the literals vlan, tagged, or
* untagged, then it is assumed that the user knows what she is
* doing, and the filter is not reformatted.
*/
if ((pcap_datalink(p) == DLT_EN10MB) &&
(filter != NULL) &&
(strstr(filter,"vlan") == NULL)) {
char *tmp_filter;
char *fmt = "( (not ether proto 0x8100) and (%s) ) or ( vlan and (%s) )";
tmp_filter = (char *)malloc((strlen(filter) * 2) + strlen(fmt) + 1);
if (tmp_filter == NULL) {
fprintf(stderr,"PCAP: malloc failed\n");
err_exit("Aborting",-1);
} }
}
if(!m->name) {
fprintf(stderr, "Request analysis module %s not found\n", optarg);
exit(1);
}
break;
case 'h':
usage();
printf("Do 'man ssldump' for documentation\n");
exit(1);
sprintf(tmp_filter,fmt,filter,filter); case '?':
free(filter); usage();
filter = tmp_filter; exit(1);
/* must be an SSL flag. This is kind of a gross
special case */
default:
parse_ssl_flag(c);
break;
}
}
argv += optind;
argc -= optind;
if(!file) {
if(!interface_name) {
if(pcap_findalldevs(&interfaces, errbuf) == -1) {
fprintf(stderr, "PCAP: %s\n", errbuf);
err_exit("Aborting", -1);
}
interface_name = interfaces->name;
if(!interface_name) {
fprintf(stderr, "PCAP: %s\n", errbuf);
err_exit("Aborting", -1);
}
}
if(!(p = pcap_open_live(interface_name, 65535, !no_promiscuous, 1000,
errbuf))) {
fprintf(stderr, "PCAP: %s\n", errbuf);
err_exit("Aborting", -1);
}
if(pcap_lookupnet(interface_name, &localnet, &netmask, errbuf) < 0)
fprintf(stderr, "PCAP: %s\n", errbuf);
} else {
if(!(p = pcap_open_offline(file, errbuf))) {
fprintf(stderr, "PCAP: %s\n", errbuf);
err_exit("Aborting", -1);
}
netmask = 0;
localnet = 0;
}
if(argc != 0)
filter = collapse_args(argc, argv);
if(filter) {
struct bpf_program fp;
/* (F5 patch)
* reformat filter to include traffic with or without the 802.1q
* vlan header. for example, "port 80" becomes:
* "( port 80 ) or ( vlan and port 80 )".
* note that if the filter includes the literals vlan, tagged, or
* untagged, then it is assumed that the user knows what she is
* doing, and the filter is not reformatted.
*/
if((pcap_datalink(p) == DLT_EN10MB) && (filter != NULL) &&
(strstr(filter, "vlan") == NULL)) {
char *tmp_filter;
char *fmt = "( (not ether proto 0x8100) and (%s) ) or ( vlan and (%s) )";
tmp_filter = (char *)malloc((strlen(filter) * 2) + strlen(fmt) + 1);
if(tmp_filter == NULL) {
fprintf(stderr, "PCAP: malloc failed\n");
err_exit("Aborting", -1);
} }
if(pcap_compile(p,&fp,filter,0,netmask)<0) sprintf(tmp_filter, fmt, filter, filter);
verr_exit("PCAP: %s\n",pcap_geterr(p)); free(filter);
filter = tmp_filter;
if(pcap_setfilter(p,&fp)<0)
verr_exit("PCAP: %s\n",pcap_geterr(p));
} }
pcap_if_type=pcap_datalink(p); if(pcap_compile(p, &fp, filter, 0, netmask) < 0)
verr_exit("PCAP: %s\n", pcap_geterr(p));
if(!(NET_print_flags & NET_PRINT_JSON)) if(pcap_setfilter(p, &fp) < 0)
if(NET_print_flags & NET_PRINT_TYPESET) verr_exit("PCAP: %s\n", pcap_geterr(p));
printf("\n.nf\n.ps -2\n");
if((r=network_handler_create(mod,&n)))
err_exit("Couldn't create network handler",r);
pcap_loop(p,-1,pcap_cb,(u_char *)n);
if(!(NET_print_flags & NET_PRINT_JSON))
if(NET_print_flags & NET_PRINT_TYPESET)
printf("\n.ps\n.fi\n");
freed_conn = destroy_all_conn();
if(freed_conn && !(NET_print_flags & NET_PRINT_JSON))
printf("Cleaned %d remaining connection(s) from connection pool\n", freed_conn);
network_handler_destroy(mod, &n);
pcap_close(p);
free(n);
if(filter)
free(filter);
if(file)
free(file);
if(interface_name)
free(interface_name);
if(SSL_keyfile)
free(SSL_keyfile);
if(SSL_keylogfile)
free(SSL_keylogfile);
if(SSL_password)
free(SSL_password);
if (logger)
{
logger->vtbl->deinit();
}
exit(0);
} }
pcap_if_type = pcap_datalink(p);
char *collapse_args(argc,argv) if(!(NET_print_flags & NET_PRINT_JSON))
int argc; if(NET_print_flags & NET_PRINT_TYPESET)
char **argv; printf("\n.nf\n.ps -2\n");
{
int i,len=0;
char *ret;
if(!argc) if((r = network_handler_create(mod, &n)))
return(0); err_exit("Couldn't create network handler", r);
for(i=0;i<argc;i++){ pcap_loop(p, -1, pcap_cb, (u_char *)n);
len+=strlen(argv[i])+1;
}
if(!(ret=(char *)malloc(len))) if(!(NET_print_flags & NET_PRINT_JSON))
err_exit("Out of memory",1); if(NET_print_flags & NET_PRINT_TYPESET)
printf("\n.ps\n.fi\n");
len=0; freed_conn = destroy_all_conn();
for(i=0;i<argc;i++){ if(freed_conn && !(NET_print_flags & NET_PRINT_JSON))
strcpy(ret+len,argv[i]); printf("Cleaned %d remaining connection(s) from connection pool\n",
len+=strlen(argv[i]); freed_conn);
if(i!=(argc-1)) network_handler_destroy(mod, &n);
ret[len++]=' '; pcap_close(p);
}
return(ret); free(n);
if(filter)
free(filter);
if(file)
free(file);
if(interface_name)
free(interface_name);
if(SSL_keyfile)
free(SSL_keyfile);
if(SSL_keylogfile)
free(SSL_keylogfile);
if(SSL_password)
free(SSL_password);
if(logger) {
logger->vtbl->deinit();
} }
exit(0);
}
char *collapse_args(int argc, char **argv) {
int i, len = 0;
char *ret;
if(!argc)
return (0);
for(i = 0; i < argc; i++) {
len += strlen(argv[i]) + 1;
}
if(!(ret = (char *)malloc(len)))
err_exit("Out of memory", 1);
len = 0;
for(i = 0; i < argc; i++) {
strcpy(ret + len, argv[i]);
len += strlen(argv[i]);
if(i != (argc - 1))
ret[len++] = ' ';
}
return (ret);
}

71
base/print_utils.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: print_utils.c,v 1.2 2000/10/17 16:09:58 ekr Exp $ $Id: print_utils.c,v 1.2 2000/10/17 16:09:58 ekr Exp $
@ -43,45 +44,43 @@
ekr@rtfm.com Mon Feb 15 17:23:36 1999 ekr@rtfm.com Mon Feb 15 17:23:36 1999
*/ */
int explain(char *format, ...) {
va_list ap;
int explain(char *format,...) va_start(ap, format);
{
va_list ap;
va_start(ap,format); INDENT;
INDENT; vprintf(format, ap);
va_end(ap);
return (0);
}
vprintf(format,ap); int exdump(name, data) char *name;
va_end(ap); Data *data;
return(0); {
int i, j;
char prefix[100];
INDENT;
if(name) {
sprintf(prefix, "%s[%d]=\n", name, data->len);
printf("%s", prefix);
INDENT_INCR;
} }
for(i = 0; i < data->len; i++) {
int exdump(name,data) if(!i && (data->len > 8))
char *name; INDENT;
Data *data; if((data->len > 8) && i && !(i % 12)) {
{
int i,j;
char prefix[100];
INDENT;
if(name){
sprintf(prefix,"%s[%d]=\n",name,data->len);
printf("%s",prefix);
INDENT_INCR;
}
for(i=0;i<data->len;i++){
if(!i && (data->len>8)) INDENT;
if((data->len>8) && i && !(i%12)){
LF;INDENT;
}
printf("%.2x ",data->data[i]&255);
}
if(name) INDENT_POP;
if(data->len>8 && i%12)
LF; LF;
return(0); INDENT;
}
printf("%.2x ", data->data[i] & 255);
} }
if(name)
INDENT_POP;
if(data->len > 8 && i % 12)
LF;
return (0);
}

11
base/print_utils.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: print_utils.h,v 1.2 2000/10/17 16:09:58 ekr Exp $ $Id: print_utils.h,v 1.2 2000/10/17 16:09:58 ekr Exp $
@ -43,14 +44,10 @@
ekr@rtfm.com Mon Feb 15 17:23:56 1999 ekr@rtfm.com Mon Feb 15 17:23:56 1999
*/ */
#ifndef _print_utils_h #ifndef _print_utils_h
#define _print_utils_h #define _print_utils_h
int explain PROTO_LIST((char *format,...)); int explain PROTO_LIST((char *format, ...));
int exdump PROTO_LIST((char *name, int exdump PROTO_LIST((char *name, Data *data));
Data *data));
#endif #endif

66
base/proto_mod.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: proto_mod.c,v 1.3 2001/07/20 23:33:14 ekr Exp $ $Id: proto_mod.c,v 1.3 2001/07/20 23:33:14 ekr Exp $
@ -43,45 +44,40 @@
ekr@rtfm.com Thu Jan 7 22:35:23 1999 ekr@rtfm.com Thu Jan 7 22:35:23 1999
*/ */
#include "network.h" #include "network.h"
int create_proto_handler(mod,ctx,handlerp,conn,first_packet) int create_proto_handler(proto_mod *mod,
proto_mod *mod; proto_ctx *ctx,
proto_ctx *ctx; proto_handler **handlerp,
proto_handler **handlerp; tcp_conn *conn,
tcp_conn *conn; struct timeval *first_packet) {
struct timeval *first_packet; int r, _status;
{ proto_handler *handler = 0;
int r,_status;
proto_handler *handler=0;
if(!(handler=(proto_handler *)calloc(1,sizeof(proto_handler)))) if(!(handler = (proto_handler *)calloc(1, sizeof(proto_handler))))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
handler->vtbl=mod->vtbl; handler->vtbl = mod->vtbl;
if((r=mod->vtbl->create(mod->handle,ctx,conn,&handler->obj, if((r = mod->vtbl->create(mod->handle, ctx, conn, &handler->obj,
&conn->i_addr,conn->i_port,&conn->r_addr,conn->r_port,first_packet))) &conn->i_addr, conn->i_port, &conn->r_addr,
ABORT(r); conn->r_port, first_packet)))
ABORT(r);
*handlerp=handler; *handlerp = handler;
_status=0; _status = 0;
abort: abort:
if(_status){ if(_status) {
destroy_proto_handler(&handler); destroy_proto_handler(&handler);
}
return(_status);
} }
return (_status);
}
int destroy_proto_handler(handlerp) int destroy_proto_handler(proto_handler **handlerp) {
proto_handler **handlerp; if(!handlerp || !*handlerp)
{ return (0);
if(!handlerp || !*handlerp)
return(0);
(*handlerp)->vtbl->destroy(&(*handlerp)->obj); (*handlerp)->vtbl->destroy(&(*handlerp)->obj);
free(*handlerp); free(*handlerp);
*handlerp=0; *handlerp = 0;
return(0); return (0);
} }

84
base/proto_mod.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: proto_mod.h,v 1.4 2001/11/26 22:28:16 ekr Exp $ $Id: proto_mod.h,v 1.4 2001/11/26 22:28:16 ekr Exp $
@ -43,62 +44,72 @@
ekr@rtfm.com Thu Dec 24 21:10:05 1998 ekr@rtfm.com Thu Dec 24 21:10:05 1998
*/ */
#ifndef _proto_mod_h #ifndef _proto_mod_h
#define _proto_mod_h #define _proto_mod_h
typedef struct proto_obj_ proto_obj; typedef struct proto_obj_ proto_obj;
typedef struct proto_ctx_ proto_ctx; typedef struct proto_ctx_ proto_ctx;
#define DIR_I2R 1 #define DIR_I2R 1
#define DIR_R2I 2 #define DIR_R2I 2
struct proto_mod_vtbl_ { struct proto_mod_vtbl_ {
int (*parse_flags) PROTO_LIST((char *str)); int(*parse_flags) PROTO_LIST((char *str));
int (*parse_flag) PROTO_LIST((int flag)); int(*parse_flag) PROTO_LIST((int flag));
int (*create_ctx) PROTO_LIST((void *handle,proto_ctx **ctxp)); int(*create_ctx) PROTO_LIST((void *handle, proto_ctx **ctxp));
int (*create) PROTO_LIST((void *handle,proto_ctx *ctx, int(*create) PROTO_LIST((void *handle,
tcp_conn *conn, proto_ctx *ctx,
proto_obj **objp, tcp_conn *conn,
struct sockaddr_storage *i_addr,u_short i_port, proto_obj **objp,
struct sockaddr_storage *r_addr,u_short r_port,struct timeval *time_base)); struct sockaddr_storage *i_addr,
int (*destroy_ctx) PROTO_LIST((void *handle,proto_ctx **ctxp)); u_short i_port,
int (*destroy) PROTO_LIST((proto_obj **objp)); struct sockaddr_storage *r_addr,
int (*data) PROTO_LIST((proto_obj *obj,segment *data,int direction)); u_short r_port,
int (*close) PROTO_LIST((proto_obj *obj,packet *p,int direction)); struct timeval *time_base));
int(*destroy_ctx) PROTO_LIST((void *handle, proto_ctx **ctxp));
int(*destroy) PROTO_LIST((proto_obj * *objp));
int(*data) PROTO_LIST((proto_obj * obj, segment *data, int direction));
int(*close) PROTO_LIST((proto_obj * obj, packet *p, int direction));
}; };
struct proto_mod_ { struct proto_mod_ {
void *handle; void *handle;
struct proto_mod_vtbl_ *vtbl; struct proto_mod_vtbl_ *vtbl;
}; };
struct proto_handler_ { struct proto_handler_ {
proto_obj *obj; proto_obj *obj;
struct proto_mod_vtbl_ *vtbl; struct proto_mod_vtbl_ *vtbl;
}; };
int create_proto_handler PROTO_LIST((proto_mod *mod,proto_ctx *ctx, int create_proto_handler PROTO_LIST((proto_mod * mod,
proto_handler **handlerp, proto_ctx *ctx,
tcp_conn *conn,struct timeval *first_packet)); proto_handler **handlerp,
int destroy_proto_handler PROTO_LIST((proto_handler **handlerp)); tcp_conn *conn,
struct timeval *first_packet));
int destroy_proto_handler PROTO_LIST((proto_handler * *handlerp));
// add logger
//add logger
struct logger_mod_vtbl_ { struct logger_mod_vtbl_ {
int (*init) PROTO_LIST((void *data)); int(*init) PROTO_LIST((void *data));
//deinit must be async signal safe(!!!) // deinit must be async signal safe(!!!)
int (*deinit) PROTO_LIST(()); int(*deinit) PROTO_LIST(());
int (*create) PROTO_LIST((proto_obj **objp, struct sockaddr_storage *i_addr,u_short i_port, int(*create) PROTO_LIST((proto_obj * *objp,
struct sockaddr_storage *r_addr,u_short r_port,struct timeval *time_base)); struct sockaddr_storage *i_addr,
int (*destroy) PROTO_LIST((proto_obj **objp)); u_short i_port,
int (*data) PROTO_LIST((proto_obj *obj,unsigned char *data,unsigned int len,int direction)); struct sockaddr_storage *r_addr,
int (*close) PROTO_LIST((proto_obj *obj,unsigned char *data,unsigned int len,int direction)); u_short r_port,
struct timeval *time_base));
int(*destroy) PROTO_LIST((proto_obj * *objp));
int(*data) PROTO_LIST(
(proto_obj * obj, unsigned char *data, unsigned int len, int direction));
int(*close) PROTO_LIST(
(proto_obj * obj, unsigned char *data, unsigned int len, int direction));
}; };
struct logger_mod_ { struct logger_mod_ {
char *name; char *name;
struct logger_mod_vtbl_ *vtbl; struct logger_mod_vtbl_ *vtbl;
}; };
typedef struct logger_mod_ logger_mod; typedef struct logger_mod_ logger_mod;
@ -106,4 +117,3 @@ typedef struct logger_mod_ logger_mod;
extern logger_mod *logger; extern logger_mod *logger;
#endif #endif

311
base/tcpconn.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: tcpconn.c,v 1.7 2002/08/17 01:33:16 ekr Exp $ $Id: tcpconn.c,v 1.7 2002/08/17 01:33:16 ekr Exp $
@ -43,192 +44,182 @@
ekr@rtfm.com Tue Dec 29 15:13:03 1998 ekr@rtfm.com Tue Dec 29 15:13:03 1998
*/ */
#include "network.h" #include "network.h"
#include "tcpconn.h" #include "tcpconn.h"
typedef struct conn_struct_ { typedef struct conn_struct_ {
tcp_conn conn; tcp_conn conn;
struct conn_struct_ *next; struct conn_struct_ *next;
struct conn_struct_ *prev; struct conn_struct_ *prev;
} conn_struct; } conn_struct;
int conn_number=1; int conn_number = 1;
static conn_struct *first_conn=0; static conn_struct *first_conn = 0;
extern struct timeval last_packet_seen_time; extern struct timeval last_packet_seen_time;
extern int conn_ttl; extern int conn_ttl;
static int zero_conn PROTO_LIST((tcp_conn *conn)); static int zero_conn PROTO_LIST((tcp_conn * conn));
static int zero_conn(conn) static int zero_conn(tcp_conn *conn) {
tcp_conn *conn; memset(conn, 0, sizeof(tcp_conn));
{ return (0);
memset(conn,0,sizeof(tcp_conn)); }
return(0);
}
int tcp_find_conn(tcp_conn **connp, int *directionp,struct sockaddr_storage *saddr, int tcp_find_conn(tcp_conn **connp,
u_short sport, struct sockaddr_storage *daddr, u_short dport) int *directionp,
{ struct sockaddr_storage *saddr,
conn_struct *conn; u_short sport,
struct sockaddr_storage *daddr,
u_short dport) {
conn_struct *conn;
for(conn=first_conn;conn;conn=conn->next){ for(conn = first_conn; conn; conn = conn->next) {
if(sport == conn->conn.i_port && dport == conn->conn.r_port) {
if(sport == conn->conn.i_port && dport==conn->conn.r_port){ if(!memcmp(saddr, &conn->conn.i_addr, sizeof(struct sockaddr_storage)) &&
if(!memcmp(saddr,&conn->conn.i_addr,sizeof(struct sockaddr_storage)) !memcmp(daddr, &conn->conn.r_addr, sizeof(struct sockaddr_storage))) {
&& !memcmp(daddr,&conn->conn.r_addr,sizeof(struct sockaddr_storage))) *directionp = DIR_I2R;
{ *connp = &(conn->conn);
*directionp=DIR_I2R; return (0);
*connp=&(conn->conn);
return(0);
}
}
if(dport == conn->conn.i_port && sport==conn->conn.r_port){
if(!memcmp(saddr,&conn->conn.r_addr,sizeof(struct sockaddr_storage))
&& !memcmp(daddr,&conn->conn.i_addr,sizeof(struct sockaddr_storage)))
{
*directionp=DIR_R2I;
*connp=&(conn->conn);
return(0);
}
} }
} }
return(R_NOT_FOUND); if(dport == conn->conn.i_port && sport == conn->conn.r_port) {
if(!memcmp(saddr, &conn->conn.r_addr, sizeof(struct sockaddr_storage)) &&
!memcmp(daddr, &conn->conn.i_addr, sizeof(struct sockaddr_storage))) {
*directionp = DIR_R2I;
*connp = &(conn->conn);
return (0);
}
}
} }
int tcp_create_conn(tcp_conn **connp,struct sockaddr_storage *i_addr, return (R_NOT_FOUND);
u_short i_port, struct sockaddr_storage *r_addr, u_short r_port)
{
conn_struct *conn=0;
if(!(conn=(conn_struct *)malloc(sizeof(conn_struct))))
return(R_NO_MEMORY);
conn->prev=0;
zero_conn(&conn->conn);
conn->conn.backptr=conn;
conn->conn.conn_number=conn_number++;
memcpy(&conn->conn.i_addr,i_addr,sizeof(struct sockaddr_storage));
conn->conn.i_port=i_port;
memcpy(&conn->conn.r_addr,r_addr,sizeof(struct sockaddr_storage));
conn->conn.r_port=r_port;
*connp=&(conn->conn);
/* Insert at the head of the list */
conn->next=first_conn;
if(first_conn)
first_conn->prev=conn;
first_conn=conn;
return(0);
}
int tcp_destroy_conn(conn)
tcp_conn *conn;
{
conn_struct *c=conn->backptr;
/* Detach from the list */
if(c->next){
c->next->prev=c->prev;
}
if(c->prev){
c->prev->next=c->next;
}
else {
first_conn=c->next;
}
destroy_proto_handler(&conn->analyzer);
free_tcp_segment_queue(conn->i2r.oo_queue);
free_tcp_segment_queue(conn->r2i.oo_queue);
free(conn->i_name);
free(conn->r_name);
free(conn->i_num);
free(conn->r_num);
zero_conn(conn);
free(conn->backptr);
free(conn);
return(0);
}
int clean_old_conn() {
conn_struct *conn;
tcp_conn *tcpconn;
struct timeval dt;
int i = 0;
if(!last_packet_seen_time.tv_sec)
return 0; // Still processing first block of packets
conn = first_conn;
while(conn) {
tcpconn = &conn->conn;
conn=conn->next;
if(timestamp_diff(&last_packet_seen_time, &tcpconn->last_seen_time, &dt))
continue;
if(dt.tv_sec > conn_ttl) {
i++;
tcp_destroy_conn(tcpconn);
}
}
return i;
} }
int destroy_all_conn() { int tcp_create_conn(tcp_conn **connp,
int i = 0; struct sockaddr_storage *i_addr,
while(first_conn) { u_short i_port,
i++; struct sockaddr_storage *r_addr,
tcp_destroy_conn(&first_conn->conn); u_short r_port) {
} conn_struct *conn = 0;
return i;
if(!(conn = (conn_struct *)malloc(sizeof(conn_struct))))
return (R_NO_MEMORY);
conn->prev = 0;
zero_conn(&conn->conn);
conn->conn.backptr = conn;
conn->conn.conn_number = conn_number++;
memcpy(&conn->conn.i_addr, i_addr, sizeof(struct sockaddr_storage));
conn->conn.i_port = i_port;
memcpy(&conn->conn.r_addr, r_addr, sizeof(struct sockaddr_storage));
conn->conn.r_port = r_port;
*connp = &(conn->conn);
/* Insert at the head of the list */
conn->next = first_conn;
if(first_conn)
first_conn->prev = conn;
first_conn = conn;
return (0);
} }
int free_tcp_segment_queue(seg) int tcp_destroy_conn(tcp_conn *conn) {
segment *seg; conn_struct *c = conn->backptr;
{
segment *tmp;
while(seg){ /* Detach from the list */
tmp=seg->next; if(c->next) {
packet_destroy(seg->p); c->next->prev = c->prev;
free(seg); }
seg=tmp; if(c->prev) {
} c->prev->next = c->next;
} else {
return(0); first_conn = c->next;
} }
int copy_tcp_segment_queue(out,in) destroy_proto_handler(&conn->analyzer);
segment **out; free_tcp_segment_queue(conn->i2r.oo_queue);
segment *in; free_tcp_segment_queue(conn->r2i.oo_queue);
{ free(conn->i_name);
int r,_status; free(conn->r_name);
segment *base=0; free(conn->i_num);
free(conn->r_num);
zero_conn(conn);
free(conn->backptr);
free(conn);
for(;in;in=in->next){ return (0);
if(!(*out=(segment *)calloc(1,sizeof(segment)))) }
ABORT(R_NO_MEMORY);
if(!base) base=*out;
if((r=packet_copy(in->p,&(*out)->p))) int clean_old_conn(void) {
ABORT(r); conn_struct *conn;
out=&(*out)->next; /* Move the pointer we're assigning to */ tcp_conn *tcpconn;
struct timeval dt;
int i = 0;
if(!last_packet_seen_time.tv_sec)
return 0; // Still processing first block of packets
conn = first_conn;
while(conn) {
tcpconn = &conn->conn;
conn = conn->next;
if(timestamp_diff(&last_packet_seen_time, &tcpconn->last_seen_time, &dt))
continue;
if(dt.tv_sec > conn_ttl) {
i++;
tcp_destroy_conn(tcpconn);
} }
_status=0;
abort:
if(_status){
free_tcp_segment_queue(base);
}
return(_status);
} }
return i;
}
int destroy_all_conn(void) {
int i = 0;
while(first_conn) {
i++;
tcp_destroy_conn(&first_conn->conn);
}
return i;
}
int free_tcp_segment_queue(segment *seg) {
segment *tmp;
while(seg) {
tmp = seg->next;
packet_destroy(seg->p);
free(seg);
seg = tmp;
}
return (0);
}
int copy_tcp_segment_queue(segment **out, segment *in) {
int r, _status;
segment *base = 0;
for(; in; in = in->next) {
if(!(*out = (segment *)calloc(1, sizeof(segment))))
ABORT(R_NO_MEMORY);
if(!base)
base = *out;
if((r = packet_copy(in->p, &(*out)->p)))
ABORT(r);
out = &(*out)->next; /* Move the pointer we're assigning to */
}
_status = 0;
abort:
if(_status) {
free_tcp_segment_queue(base);
}
return (_status);
}

93
base/tcpconn.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: tcpconn.h,v 1.4 2001/07/20 23:33:15 ekr Exp $ $Id: tcpconn.h,v 1.4 2001/07/20 23:33:15 ekr Exp $
@ -43,70 +44,72 @@
ekr@rtfm.com Tue Dec 29 13:00:52 1998 ekr@rtfm.com Tue Dec 29 13:00:52 1998
*/ */
#ifndef _tcpconn_h #ifndef _tcpconn_h
#define _tcpconn_h #define _tcpconn_h
typedef struct segment_ { typedef struct segment_ {
u_char *data; u_char *data;
u_int len; u_int len;
tcp_seq s_seq; tcp_seq s_seq;
packet *p; packet *p;
struct segment_ *next; struct segment_ *next;
} segment; } segment;
typedef struct stream_data_ { typedef struct stream_data_ {
tcp_seq seq; tcp_seq seq;
tcp_seq ack; tcp_seq ack;
short close; short close;
segment *oo_queue; segment *oo_queue;
} stream_data; } stream_data;
typedef struct tcp_conn_ { typedef struct tcp_conn_ {
int conn_number; int conn_number;
int state; int state;
#define TCP_STATE_SYN1 1 #define TCP_STATE_SYN1 1
#define TCP_STATE_SYN2 2 #define TCP_STATE_SYN2 2
#define TCP_STATE_ACK 3 #define TCP_STATE_ACK 3
#define TCP_STATE_ESTABLISHED 4 #define TCP_STATE_ESTABLISHED 4
#define TCP_STATE_FIN1 5 #define TCP_STATE_FIN1 5
#define TCP_STATE_CLOSED 6 #define TCP_STATE_CLOSED 6
/*The address which sent the first SYN*/ /*The address which sent the first SYN*/
struct sockaddr_storage i_addr; struct sockaddr_storage i_addr;
u_short i_port; u_short i_port;
char *i_name; char *i_name;
char *i_num; char *i_num;
/*The address which sent the second SYN*/ /*The address which sent the second SYN*/
struct sockaddr_storage r_addr; struct sockaddr_storage r_addr;
u_short r_port; u_short r_port;
char *r_name; char *r_name;
char *r_num; char *r_num;
stream_data i2r; /*The stream from initiator to responder*/ stream_data i2r; /*The stream from initiator to responder*/
stream_data r2i; /*The stream from responder to initiator*/ stream_data r2i; /*The stream from responder to initiator*/
struct timeval start_time; struct timeval start_time;
struct timeval last_seen_time; struct timeval last_seen_time;
proto_handler *analyzer; /*The analyzer to call with new data*/ proto_handler *analyzer; /*The analyzer to call with new data*/
struct conn_struct_ *backptr; struct conn_struct_ *backptr;
} tcp_conn; } tcp_conn;
int tcp_find_conn PROTO_LIST((tcp_conn **connp, int tcp_find_conn PROTO_LIST((tcp_conn * *connp,
int *directionp, int *directionp,
struct sockaddr_storage *src_addr, u_short src_port, struct sockaddr_storage *src_addr,
struct sockaddr_storage *dst_addr, u_short dst_port)); u_short src_port,
struct sockaddr_storage *dst_addr,
u_short dst_port));
int tcp_create_conn PROTO_LIST((tcp_conn **connp, int tcp_create_conn PROTO_LIST((tcp_conn * *connp,
struct sockaddr_storage *initiator_addr, u_short initiator_port, struct sockaddr_storage *initiator_addr,
struct sockaddr_storage *responder_addr, u_short responder_port)); u_short initiator_port,
struct sockaddr_storage *responder_addr,
u_short responder_port));
int tcp_destroy_conn PROTO_LIST((tcp_conn *conn)); int tcp_destroy_conn PROTO_LIST((tcp_conn * conn));
int free_tcp_segment_queue PROTO_LIST((segment *seg)); int free_tcp_segment_queue PROTO_LIST((segment * seg));
int copy_tcp_segment_queue PROTO_LIST((segment **out,segment *in)); int copy_tcp_segment_queue PROTO_LIST((segment * *out, segment *in));
int clean_old_conn(void); int clean_old_conn(void);
int destroy_all_conn(void); int destroy_all_conn(void);
#endif #endif

749
base/tcppack.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: tcppack.c,v 1.11 2002/09/09 21:02:58 ekr Exp $ $Id: tcppack.c,v 1.11 2002/09/09 21:02:58 ekr Exp $
@ -43,169 +44,159 @@
ekr@rtfm.com Tue Dec 29 12:43:39 1998 ekr@rtfm.com Tue Dec 29 12:43:39 1998
*/ */
#include "network.h" #include "network.h"
#ifndef _WIN32 #ifndef _WIN32
# include <sys/socket.h> #include <sys/socket.h>
# include <arpa/inet.h> #include <arpa/inet.h>
# ifndef LINUX #ifndef LINUX
# include <netinet/tcp_seq.h> #include <netinet/tcp_seq.h>
# else
# define SEQ_LT(x,y) ((int)((x)-(y))<0)
# endif
#else #else
# include <winsock2.h> #define SEQ_LT(x, y) ((int)((x) - (y)) < 0)
# define SEQ_LT(x,y) ((int)((x)-(y))<0) #endif
#else
#include <winsock2.h>
#define SEQ_LT(x, y) ((int)((x) - (y)) < 0)
#endif #endif
#include <ctype.h> #include <ctype.h>
#include "debug.h" #include "debug.h"
#include "tcpconn.h" #include "tcpconn.h"
#include "tcppack.h" #include "tcppack.h"
static int process_data_segment PROTO_LIST((tcp_conn * conn,
proto_mod *handler,
packet *p,
stream_data *stream,
int direction));
static int new_connection PROTO_LIST(
(proto_mod * handler, proto_ctx *ctx, packet *p, tcp_conn **connp));
static int print_tcp_packet PROTO_LIST((packet * p));
int STRIM PROTO_LIST((UINT4 _seq, segment *s));
static int process_data_segment PROTO_LIST((tcp_conn *conn, int process_tcp_packet(proto_mod *handler, proto_ctx *ctx, packet *p) {
proto_mod *handler,packet *p,stream_data *stream,int direction)); int r, _status;
static int new_connection PROTO_LIST((proto_mod *handler,proto_ctx *ctx, int direction;
packet *p,tcp_conn **connp)); stream_data *stream;
static int print_tcp_packet PROTO_LIST((packet *p)); tcp_conn *conn;
int STRIM PROTO_LIST((UINT4 _seq,segment *s));
int process_tcp_packet(handler,ctx,p) if(p->len < 20)
proto_mod *handler; ABORT(1);
proto_ctx *ctx;
packet *p;
{
int r,_status;
int direction;
stream_data *stream;
tcp_conn *conn;
if(p->len < 20) p->tcp = (struct tcphdr *)p->data;
ABORT(1);
p->tcp=(struct tcphdr *)p->data; print_tcp_packet(p);
print_tcp_packet(p); if((r = tcp_find_conn(&conn, &direction, &p->i_addr.so_st,
ntohs(p->tcp->th_sport), &p->r_addr.so_st,
if((r=tcp_find_conn(&conn,&direction,&p->i_addr.so_st, ntohs(p->tcp->th_dport)))) {
ntohs(p->tcp->th_sport),&p->r_addr.so_st,ntohs(p->tcp->th_dport)))){ if(r != R_NOT_FOUND)
if(r!=R_NOT_FOUND)
ABORT(r);
if((p->tcp->th_flags & TH_SYN)!=TH_SYN){
DBG((0,"TCP: rejecting packet from unknown connection, seq: %u\n",ntohl(p->tcp->th_seq)));
return(0);
}
if((r=new_connection(handler,ctx,p,&conn)))
ABORT(r);
return(0);
}
stream=direction==DIR_R2I?&conn->r2i:&conn->i2r;
memcpy(&conn->last_seen_time,&p->ts,sizeof(struct timeval));
switch(conn->state){
case TCP_STATE_SYN1:
if(direction == DIR_R2I && (p->tcp->th_flags & TH_SYN)) {
DBG((0,"SYN2 seq: %u",ntohl(p->tcp->th_seq)));
conn->r2i.seq=ntohl(p->tcp->th_seq)+1;
conn->r2i.ack=ntohl(p->tcp->th_ack)+1;
conn->state=TCP_STATE_ACK;
}
break;
case TCP_STATE_SYN2:
if(direction == DIR_I2R && (p->tcp->th_flags & TH_SYN)) {
DBG((0,"SYN1 seq: %u",ntohl(p->tcp->th_seq)));
conn->i2r.seq=ntohl(p->tcp->th_seq)+1;
conn->i2r.ack=ntohl(p->tcp->th_ack)+1;
conn->state=TCP_STATE_ACK;
}
break;
case TCP_STATE_ACK:
{
if(direction != DIR_I2R)
break;
DBG((0,"ACK seq: %u",ntohl(p->tcp->th_seq)));
conn->i2r.ack=ntohl(p->tcp->th_ack)+1;
if(!(NET_print_flags & NET_PRINT_JSON)) {
if(NET_print_flags & NET_PRINT_TYPESET)
printf("\\fC");
printf("New TCP connection #%d: %s(%d) <-> %s(%d)\n",
conn->conn_number,
conn->i_name,conn->i_port,
conn->r_name,conn->r_port);
if(NET_print_flags & NET_PRINT_TYPESET)
printf("\\fR");
}
conn->state=TCP_STATE_ESTABLISHED;
}
case TCP_STATE_ESTABLISHED:
case TCP_STATE_FIN1:
{
if(p->tcp->th_flags & TH_SYN)
break;
if((r=process_data_segment(conn,handler,p,stream,direction)))
ABORT(r);
}
break;
default:
break;
}
if(conn->state==TCP_STATE_CLOSED)
tcp_destroy_conn(conn);
_status=0;
abort:
return(_status);
}
static int new_connection(handler,ctx,p,connp)
proto_mod *handler;
proto_ctx *ctx;
packet *p;
tcp_conn **connp;
{
int r,_status;
tcp_conn *conn=0;
if ((p->tcp->th_flags & (TH_SYN|TH_ACK))==TH_SYN) {
if((r=tcp_create_conn(&conn,&p->i_addr.so_st,ntohs(p->tcp->th_sport),
&p->r_addr.so_st,ntohs(p->tcp->th_dport))))
ABORT(r);
DBG((0,"SYN1 seq: %u",ntohl(p->tcp->th_seq)));
conn->i2r.seq=ntohl(p->tcp->th_seq)+1;
conn->i2r.ack=ntohl(p->tcp->th_ack)+1;
conn->state=TCP_STATE_SYN1;
} else { // SYN&ACK comes first somehow
if((r=tcp_create_conn(&conn,&p->r_addr.so_st,ntohs(p->tcp->th_dport),
&p->i_addr.so_st,ntohs(p->tcp->th_sport))))
ABORT(r);
DBG((0,"SYN2 seq: %u",ntohl(p->tcp->th_seq)));
conn->r2i.seq=ntohl(p->tcp->th_seq)+1;
conn->r2i.ack=ntohl(p->tcp->th_ack)+1;
conn->state=TCP_STATE_SYN2;
}
memcpy(&conn->start_time,&p->ts,sizeof(struct timeval));
memcpy(&conn->last_seen_time,&p->ts,sizeof(struct timeval));
lookuphostname(&conn->i_addr,&conn->i_name);
lookuphostname(&conn->r_addr,&conn->r_name);
addrtotext(&conn->i_addr,&conn->i_num);
addrtotext(&conn->r_addr,&conn->r_num);
if((r=create_proto_handler(handler,ctx,&conn->analyzer,conn,&p->ts)))
ABORT(r); ABORT(r);
*connp=conn; if((p->tcp->th_flags & TH_SYN) != TH_SYN) {
_status=0; DBG((0, "TCP: rejecting packet from unknown connection, seq: %u\n",
abort: ntohl(p->tcp->th_seq)));
return(_status); return (0);
}
if((r = new_connection(handler, ctx, p, &conn)))
ABORT(r);
return (0);
} }
stream = direction == DIR_R2I ? &conn->r2i : &conn->i2r;
memcpy(&conn->last_seen_time, &p->ts, sizeof(struct timeval));
switch(conn->state) {
case TCP_STATE_SYN1:
if(direction == DIR_R2I && (p->tcp->th_flags & TH_SYN)) {
DBG((0, "SYN2 seq: %u", ntohl(p->tcp->th_seq)));
conn->r2i.seq = ntohl(p->tcp->th_seq) + 1;
conn->r2i.ack = ntohl(p->tcp->th_ack) + 1;
conn->state = TCP_STATE_ACK;
}
break;
case TCP_STATE_SYN2:
if(direction == DIR_I2R && (p->tcp->th_flags & TH_SYN)) {
DBG((0, "SYN1 seq: %u", ntohl(p->tcp->th_seq)));
conn->i2r.seq = ntohl(p->tcp->th_seq) + 1;
conn->i2r.ack = ntohl(p->tcp->th_ack) + 1;
conn->state = TCP_STATE_ACK;
}
break;
case TCP_STATE_ACK: {
if(direction != DIR_I2R)
break;
DBG((0, "ACK seq: %u", ntohl(p->tcp->th_seq)));
conn->i2r.ack = ntohl(p->tcp->th_ack) + 1;
if(!(NET_print_flags & NET_PRINT_JSON)) {
if(NET_print_flags & NET_PRINT_TYPESET)
printf("\\fC");
printf("New TCP connection #%d: %s(%d) <-> %s(%d)\n", conn->conn_number,
conn->i_name, conn->i_port, conn->r_name, conn->r_port);
if(NET_print_flags & NET_PRINT_TYPESET)
printf("\\fR");
}
conn->state = TCP_STATE_ESTABLISHED;
}
case TCP_STATE_ESTABLISHED:
case TCP_STATE_FIN1: {
if(p->tcp->th_flags & TH_SYN)
break;
if((r = process_data_segment(conn, handler, p, stream, direction)))
ABORT(r);
} break;
default:
break;
}
if(conn->state == TCP_STATE_CLOSED)
tcp_destroy_conn(conn);
_status = 0;
abort:
return (_status);
}
static int new_connection(proto_mod *handler,
proto_ctx *ctx,
packet *p,
tcp_conn **connp) {
int r, _status;
tcp_conn *conn = 0;
if((p->tcp->th_flags & (TH_SYN | TH_ACK)) == TH_SYN) {
if((r = tcp_create_conn(&conn, &p->i_addr.so_st, ntohs(p->tcp->th_sport),
&p->r_addr.so_st, ntohs(p->tcp->th_dport))))
ABORT(r);
DBG((0, "SYN1 seq: %u", ntohl(p->tcp->th_seq)));
conn->i2r.seq = ntohl(p->tcp->th_seq) + 1;
conn->i2r.ack = ntohl(p->tcp->th_ack) + 1;
conn->state = TCP_STATE_SYN1;
} else { // SYN&ACK comes first somehow
if((r = tcp_create_conn(&conn, &p->r_addr.so_st, ntohs(p->tcp->th_dport),
&p->i_addr.so_st, ntohs(p->tcp->th_sport))))
ABORT(r);
DBG((0, "SYN2 seq: %u", ntohl(p->tcp->th_seq)));
conn->r2i.seq = ntohl(p->tcp->th_seq) + 1;
conn->r2i.ack = ntohl(p->tcp->th_ack) + 1;
conn->state = TCP_STATE_SYN2;
}
memcpy(&conn->start_time, &p->ts, sizeof(struct timeval));
memcpy(&conn->last_seen_time, &p->ts, sizeof(struct timeval));
lookuphostname(&conn->i_addr, &conn->i_name);
lookuphostname(&conn->r_addr, &conn->r_name);
addrtotext(&conn->i_addr, &conn->i_num);
addrtotext(&conn->r_addr, &conn->r_num);
if((r = create_proto_handler(handler, ctx, &conn->analyzer, conn, &p->ts)))
ABORT(r);
*connp = conn;
_status = 0;
abort:
return (_status);
}
/*#define STRIM(_seq,s) { \ /*#define STRIM(_seq,s) { \
int l;\ int l;\
int off;\ int off;\
@ -218,263 +209,253 @@ static int new_connection(handler,ctx,p,connp)
if((s)->next) { \ if((s)->next) { \
if((s)->s_seq >= (s)->next->s_seq) {\ if((s)->s_seq >= (s)->next->s_seq) {\
l=(s)->next->s_seq - (s)->s_seq; \ l=(s)->next->s_seq - (s)->s_seq; \
if((s)->len){\ if((s)->len){\
(s)->len-=(l+1); \ (s)->len-=(l+1); \
(s)->s_seq-=(l+1);\ (s)->s_seq-=(l+1);\
}\ }\
}\ }\
}\ }\
} }
*/ */
static int process_data_segment(conn,handler,p,stream,direction) static int process_data_segment(tcp_conn *conn,
tcp_conn *conn; proto_mod *handler,
proto_mod *handler; packet *p,
packet *p; stream_data *stream,
stream_data *stream; int direction) {
int direction; int r, _status;
{ tcp_seq seq, right_edge;
int r,_status; segment _seg;
tcp_seq seq,right_edge; segment *seg, *nseg = 0;
segment _seg; long l;
segment *seg,*nseg=0;
long l;
l=p->len - p->tcp->th_off * 4; l = p->len - p->tcp->th_off * 4;
if(l < 0) { if(l < 0) {
fprintf(stderr,"Malformed packet, computed TCP segment size is negative, skipping ...\n"); fprintf(stderr,
return(0); "Malformed packet, computed TCP segment size is negative, skipping "
} "...\n");
return (0);
if(stream->close){
DBG((0,"Rejecting packet received after FIN: %u:%u(%u)",
ntohl(p->tcp->th_seq),ntohl(p->tcp->th_seq+l),l));
return(0);
}
/*The idea here is to pass all available segments
to the analyzer at once. Since we want to preserve
the segment packet data, we pass the data as a linked list of
segments*/
seq=ntohl(p->tcp->th_seq);
/*Add ACK processing logic here <TODO>*/
if(p->tcp->th_flags & TH_ACK){
long acknum,acked;
acknum=ntohl(p->tcp->th_ack);
acked=acknum-stream->ack;
if(acked && !l){
/*
if((r=timestamp_diff(&p->ts,&conn->start_time,&dt)))
ERETURN(r);
printf("%d%c%4.4d ",dt.tv_sec,'.',dt.tv_usec/100);
if(direction == DIR_R2I)
printf("S>C ");
else
printf("C>S ");
printf("ACK (%d)\n",acked); */
}
stream->ack=acknum;
}
DBG((0,"Stream Seq %u ",stream->seq));
/* Check to see if this packet has been processed already */
right_edge=seq + (p->len - (p->tcp->th_off)*4);
if(!(p->tcp->th_flags & (TH_RST)) && SEQ_LT(right_edge,stream->seq))
return(0);
if(SEQ_LT(stream->seq,seq)){
/* Out of order segment */
tcp_seq left_edge;
for(seg=0;seg;seg=seg?seg->next:stream->oo_queue){
if(seg->next->s_seq > seq)
break;
}
if(!(nseg=(segment *)calloc(1,sizeof(segment))))
ABORT(R_NO_MEMORY);
if((r=packet_copy(p,&nseg->p)))
ABORT(r);
nseg->s_seq=seq;
/*Insert this segment into the reassembly queue*/
if(seg){
nseg->next=seg->next;
seg->next=nseg;
}
else{
nseg->next=stream->oo_queue;
stream->oo_queue=nseg;
}
left_edge=seg?seg->s_seq:stream->seq;
STRIM(left_edge,nseg);
}
else{
/*First segment -- just thread the unallocated data on the
list so we can pass to the analyzer*/
_seg.next=0;
_seg.p=p;
_seg.s_seq=seq;
/*Now split the queue. Assemble as many packets as possible
and pass them to the analyzer. But process anything with a
RST in it immediately and ignore any data that might be in it
*/
if(_seg.p->tcp->th_flags & (TH_RST)){
stream->close=_seg.p->tcp->th_flags & (TH_RST);
seg=&_seg;
conn->state=TCP_STATE_CLOSED;
}
else{
STRIM(stream->seq,&_seg);
if(_seg.p->tcp->th_flags & (TH_FIN)){
stream->close=_seg.p->tcp->th_flags & (TH_FIN);
seg=&_seg;
}
else {
for(seg=&_seg;seg->next;seg=seg->next){
if(seg->p->tcp->th_flags & (TH_FIN)){
stream->close=_seg.p->tcp->th_flags & (TH_FIN);
break;
}
if(seg->len + seg->s_seq != seg->next->s_seq)
break;
}
}
/*Note that this logic is broken because it doesn't
do the CLOSE_WAIT/FIN_WAIT stuff, but it's probably
close enough, since this is a higher level protocol analyzer,
not a TCP analyzer*/
if(seg->p->tcp->th_flags & (TH_FIN) ){
if(conn->state == TCP_STATE_ESTABLISHED)
conn->state=TCP_STATE_FIN1;
else
conn->state=TCP_STATE_CLOSED;
}
free_tcp_segment_queue(stream->oo_queue);
stream->oo_queue=seg->next;
seg->next=0;
stream->seq=seg->s_seq + seg->len;
DBG((0,"Analyzing segment: %u:%u(%u)", seg->s_seq, seg->s_seq+seg->len, seg->len));
if((r=conn->analyzer->vtbl->data(conn->analyzer->obj,&_seg,direction))) {
DBG((0,"ABORT due to segment: %u:%u(%u)", seg->s_seq, seg->s_seq+seg->len, seg->len));
ABORT(r);
}
}
if(stream->close){
DBG((0,"Closing with segment: %u:%u(%u)", seg->s_seq, stream->seq, seg->len));
if((r=conn->analyzer->vtbl->close(conn->analyzer->obj,p,direction))) {
DBG((0,"ABORT due to segment: %u:%u(%u)", seg->s_seq, stream->seq, seg->len));
ABORT(r);
}
}
free_tcp_segment_queue(_seg.next);
}
_status=0;
abort:
return(_status);
} }
static int print_tcp_packet(p) if(stream->close) {
packet *p; DBG((0, "Rejecting packet received after FIN: %u:%u(%u)",
{ ntohl(p->tcp->th_seq), ntohl(p->tcp->th_seq + l), l));
char *src=0,*dst=0; return (0);
struct timeval *ts = &p->ts;
if(!(NET_print_flags & NET_PRINT_TCP_HDR))
return(0);
lookuphostname(&p->i_addr.so_st,&src);
lookuphostname(&p->r_addr.so_st,&dst);
if(!(NET_print_flags & NET_PRINT_JSON)) {
if(NET_print_flags & NET_PRINT_TS) {
printf("%lld%c%4.4lld ", (long long)ts->tv_sec,'.',(long long)ts->tv_usec/100);
}
printf("TCP: %s(%d) -> %s(%d) ",
src,
ntohs(p->tcp->th_sport),
dst,
ntohs(p->tcp->th_dport));
printf("Seq %u.(%d) ",
ntohl(p->tcp->th_seq),
p->len - p->tcp->th_off *4);
if(p->tcp->th_flags & TH_ACK)
printf("ACK %u ",ntohl(p->tcp->th_ack));
if(p->tcp->th_flags & TH_FIN)
printf("FIN ");
if(p->tcp->th_flags & TH_SYN)
printf("SYN ");
if(p->tcp->th_flags & TH_RST)
printf("RST ");
if(p->tcp->th_flags & TH_PUSH)
printf("PUSH ");
if(p->tcp->th_flags & TH_URG)
printf("URG ");
printf("\n");
}
free(src);
free(dst);
return(0);
} }
int STRIM(_seq,s) /*The idea here is to pass all available segments
UINT4 _seq; to the analyzer at once. Since we want to preserve
segment *s; the segment packet data, we pass the data as a linked list of
{ segments*/
int l; seq = ntohl(p->tcp->th_seq);
int off;
/* Test: this shouldn't damage things at all /*Add ACK processing logic here <TODO>*/
s->p->data-=4; if(p->tcp->th_flags & TH_ACK) {
s->p->len+=4; long acknum, acked;
s->s_seq-=4;
acknum = ntohl(p->tcp->th_ack);
acked = acknum - stream->ack;
if(acked && !l) {
/*
if((r=timestamp_diff(&p->ts,&conn->start_time,&dt)))
ERETURN(r);
printf("%d%c%4.4d ",dt.tv_sec,'.',dt.tv_usec/100);
if(direction == DIR_R2I)
printf("S>C ");
else
printf("C>S ");
printf("ACK (%d)\n",acked); */
}
stream->ack = acknum;
}
DBG((0, "Stream Seq %u ", stream->seq));
/* Check to see if this packet has been processed already */
right_edge = seq + (p->len - (p->tcp->th_off) * 4);
if(!(p->tcp->th_flags & (TH_RST)) && SEQ_LT(right_edge, stream->seq))
return (0);
if(SEQ_LT(stream->seq, seq)) {
/* Out of order segment */
tcp_seq left_edge;
for(seg = 0; seg; seg = seg ? seg->next : stream->oo_queue) {
if(seg->next->s_seq > seq)
break;
}
if(!(nseg = (segment *)calloc(1, sizeof(segment))))
ABORT(R_NO_MEMORY);
if((r = packet_copy(p, &nseg->p)))
ABORT(r);
nseg->s_seq = seq;
/*Insert this segment into the reassembly queue*/
if(seg) {
nseg->next = seg->next;
seg->next = nseg;
} else {
nseg->next = stream->oo_queue;
stream->oo_queue = nseg;
}
left_edge = seg ? seg->s_seq : stream->seq;
STRIM(left_edge, nseg);
} else {
/*First segment -- just thread the unallocated data on the
list so we can pass to the analyzer*/
_seg.next = 0;
_seg.p = p;
_seg.s_seq = seq;
/*Now split the queue. Assemble as many packets as possible
and pass them to the analyzer. But process anything with a
RST in it immediately and ignore any data that might be in it
*/ */
if(_seg.p->tcp->th_flags & (TH_RST)) {
stream->close = _seg.p->tcp->th_flags & (TH_RST);
seg = &_seg;
l=_seq - (s)->s_seq; /* number of bytes to trim conn->state = TCP_STATE_CLOSED;
from the left of s */ } else {
off=(s)->p->tcp->th_off*4; STRIM(stream->seq, &_seg);
if(l>((s)->p->len-off)) ERETURN(R_BAD_DATA);
/* Now remove the leading l bytes */ if(_seg.p->tcp->th_flags & (TH_FIN)) {
(s)->data=(s)->p->data + off + (l) ; stream->close = _seg.p->tcp->th_flags & (TH_FIN);
(s)->len=(s)->p->len - (off + l); seg = &_seg;
(s)->s_seq += (l); } else {
for(seg = &_seg; seg->next; seg = seg->next) {
if(seg->p->tcp->th_flags & (TH_FIN)) {
stream->close = _seg.p->tcp->th_flags & (TH_FIN);
break;
}
if(seg->len + seg->s_seq != seg->next->s_seq)
break;
}
}
/* Now trim to the right if necessary */ /*Note that this logic is broken because it doesn't
if((s)->next) { do the CLOSE_WAIT/FIN_WAIT stuff, but it's probably
if((s)->s_seq >= (s)->next->s_seq) { close enough, since this is a higher level protocol analyzer,
l=(s)->s_seq - (s)->next->s_seq; not a TCP analyzer*/
if(seg->p->tcp->th_flags & (TH_FIN)) {
if(conn->state == TCP_STATE_ESTABLISHED)
conn->state = TCP_STATE_FIN1;
else
conn->state = TCP_STATE_CLOSED;
}
if((s)->len){ free_tcp_segment_queue(stream->oo_queue);
(s)->len-=(l+1); stream->oo_queue = seg->next;
} seg->next = 0;
stream->seq = seg->s_seq + seg->len;
DBG((0, "Analyzing segment: %u:%u(%u)", seg->s_seq, seg->s_seq + seg->len,
seg->len));
if((r = conn->analyzer->vtbl->data(conn->analyzer->obj, &_seg,
direction))) {
DBG((0, "ABORT due to segment: %u:%u(%u)", seg->s_seq,
seg->s_seq + seg->len, seg->len));
ABORT(r);
} }
} }
return(0); if(stream->close) {
DBG((0, "Closing with segment: %u:%u(%u)", seg->s_seq, stream->seq,
seg->len));
if((r = conn->analyzer->vtbl->close(conn->analyzer->obj, p, direction))) {
DBG((0, "ABORT due to segment: %u:%u(%u)", seg->s_seq, stream->seq,
seg->len));
ABORT(r);
}
}
free_tcp_segment_queue(_seg.next);
} }
_status = 0;
abort:
return (_status);
}
static int print_tcp_packet(packet *p) {
char *src = 0, *dst = 0;
struct timeval *ts = &p->ts;
if(!(NET_print_flags & NET_PRINT_TCP_HDR))
return (0);
lookuphostname(&p->i_addr.so_st, &src);
lookuphostname(&p->r_addr.so_st, &dst);
if(!(NET_print_flags & NET_PRINT_JSON)) {
if(NET_print_flags & NET_PRINT_TS) {
printf("%lld%c%4.4lld ", (long long)ts->tv_sec, '.',
(long long)ts->tv_usec / 100);
}
printf("TCP: %s(%d) -> %s(%d) ", src, ntohs(p->tcp->th_sport), dst,
ntohs(p->tcp->th_dport));
printf("Seq %u.(%d) ", ntohl(p->tcp->th_seq), p->len - p->tcp->th_off * 4);
if(p->tcp->th_flags & TH_ACK)
printf("ACK %u ", ntohl(p->tcp->th_ack));
if(p->tcp->th_flags & TH_FIN)
printf("FIN ");
if(p->tcp->th_flags & TH_SYN)
printf("SYN ");
if(p->tcp->th_flags & TH_RST)
printf("RST ");
if(p->tcp->th_flags & TH_PUSH)
printf("PUSH ");
if(p->tcp->th_flags & TH_URG)
printf("URG ");
printf("\n");
}
free(src);
free(dst);
return (0);
}
int STRIM(UINT4 _seq, segment *s) {
int l;
int off;
/* Test: this shouldn't damage things at all
s->p->data-=4;
s->p->len+=4;
s->s_seq-=4;
*/
l = _seq - (s)->s_seq; /* number of bytes to trim
from the left of s */
off = (s)->p->tcp->th_off * 4;
if(l > ((s)->p->len - off))
ERETURN(R_BAD_DATA);
/* Now remove the leading l bytes */
(s)->data = (s)->p->data + off + (l);
(s)->len = (s)->p->len - (off + l);
(s)->s_seq += (l);
/* Now trim to the right if necessary */
if((s)->next) {
if((s)->s_seq >= (s)->next->s_seq) {
l = (s)->s_seq - (s)->next->s_seq;
if((s)->len) {
(s)->len -= (l + 1);
}
}
}
return (0);
}

8
base/tcppack.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: tcppack.h,v 1.3 2001/07/20 23:33:15 ekr Exp $ $Id: tcppack.h,v 1.3 2001/07/20 23:33:15 ekr Exp $
@ -43,12 +44,9 @@
ekr@rtfm.com Wed Jan 6 15:08:30 1999 ekr@rtfm.com Wed Jan 6 15:08:30 1999
*/ */
#ifndef _tcppack_h #ifndef _tcppack_h
#define _tcppack_h #define _tcppack_h
int process_tcp_packet PROTO_LIST((proto_mod *mod,proto_ctx *ctx, int process_tcp_packet PROTO_LIST((proto_mod * mod, proto_ctx *ctx, packet *p));
packet *p));
#endif #endif

45
common/include/r_assoc.h
View file

@ -39,7 +39,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_assoc.h,v 1.3 2001/12/24 06:06:26 ekr Exp $ $Id: r_assoc.h,v 1.3 2001/12/24 06:06:26 ekr Exp $
@ -47,37 +48,39 @@
ekr@rtfm.com Sun Jan 17 17:57:18 1999 ekr@rtfm.com Sun Jan 17 17:57:18 1999
*/ */
#ifndef _r_assoc_h #ifndef _r_assoc_h
#define _r_assoc_h #define _r_assoc_h
typedef struct r_assoc_ r_assoc; typedef struct r_assoc_ r_assoc;
int r_assoc_create PROTO_LIST((r_assoc **assocp)); int r_assoc_create PROTO_LIST((r_assoc * *assocp));
int r_assoc_insert PROTO_LIST((r_assoc *assoc,char *key,int len, int r_assoc_insert PROTO_LIST((r_assoc * assoc,
void *value,int (*copy)(void **new,void *old), char *key,
int (*destroy)(void *ptr),int how)); int len,
#define R_ASSOC_REPLACE 0x1 void *value,
#define R_ASSOC_NEW 0x2 int (*copy)(void **new, void *old),
int (*destroy)(void *ptr),
int how));
#define R_ASSOC_REPLACE 0x1
#define R_ASSOC_NEW 0x2
int r_assoc_fetch PROTO_LIST((r_assoc *assoc,char *key, int len, int r_assoc_fetch
void **value)); PROTO_LIST((r_assoc * assoc, char *key, int len, void **value));
int r_assoc_copy PROTO_LIST((r_assoc **new,r_assoc *old)); int r_assoc_copy PROTO_LIST((r_assoc * *new, r_assoc *old));
int r_assoc_destroy PROTO_LIST((r_assoc **assocp)); int r_assoc_destroy PROTO_LIST((r_assoc * *assocp));
/*We need iterators, but I haven't written them yet*/ /*We need iterators, but I haven't written them yet*/
typedef struct r_assoc_iterator_ { typedef struct r_assoc_iterator_ {
r_assoc *assoc; r_assoc *assoc;
int prev_chain; int prev_chain;
struct r_assoc_el_ *prev; struct r_assoc_el_ *prev;
int next_chain; int next_chain;
struct r_assoc_el_ *next; struct r_assoc_el_ *next;
} r_assoc_iterator; } r_assoc_iterator;
int r_assoc_init_iter PROTO_LIST((r_assoc *assoc,r_assoc_iterator *)); int r_assoc_init_iter PROTO_LIST((r_assoc * assoc, r_assoc_iterator *));
int r_assoc_iter PROTO_LIST((r_assoc_iterator *iter,void **key,int *keyl, int r_assoc_iter
void **val)); PROTO_LIST((r_assoc_iterator * iter, void **key, int *keyl, void **val));
int r_assoc_iter_delete PROTO_LIST((r_assoc_iterator *)); int r_assoc_iter_delete PROTO_LIST((r_assoc_iterator *));
#endif #endif

16
common/include/r_bitfield.h
View file

@ -7,20 +7,18 @@
ekr@rtfm.com Wed Oct 3 10:43:50 2001 ekr@rtfm.com Wed Oct 3 10:43:50 2001
*/ */
#ifndef _r_bitfield_h #ifndef _r_bitfield_h
#define _r_bitfield_h #define _r_bitfield_h
typedef struct r_bitfield_ { typedef struct r_bitfield_ {
UINT4 *data; UINT4 *data;
UINT4 len; UINT4 len;
UINT4 base; UINT4 base;
} r_bitfield; } r_bitfield;
int r_bitfield_set PROTO_LIST((r_bitfield *,int bit)); int r_bitfield_set PROTO_LIST((r_bitfield *, int bit));
int r_bitfield_isset PROTO_LIST((r_bitfield *,int bit)); int r_bitfield_isset PROTO_LIST((r_bitfield *, int bit));
int r_bitfield_create PROTO_LIST((r_bitfield **setp,UINT4 size)); int r_bitfield_create PROTO_LIST((r_bitfield * *setp, UINT4 size));
int r_bitfield_destroy PROTO_LIST((r_bitfield **setp)); int r_bitfield_destroy PROTO_LIST((r_bitfield * *setp));
#endif #endif

7
common/include/r_common.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_common.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_common.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Tue Dec 22 10:40:07 1998 ekr@rtfm.com Tue Dec 22 10:40:07 1998
*/ */
#ifndef _r_common_h #ifndef _r_common_h
#define _r_common_h #define _r_common_h
@ -59,7 +59,7 @@
#include "r_data.h" #include "r_data.h"
/*AAH*/ /*AAH*/
int xdump PROTO_LIST((char *label,UCHAR *data,int len)); int xdump PROTO_LIST((char *label, UCHAR *data, int len));
/* defines for possibly replaced functions */ /* defines for possibly replaced functions */
#ifndef HAVE_STRDUP #ifndef HAVE_STRDUP
@ -67,4 +67,3 @@ char *strdup PROTO_LIST((char *in));
#endif #endif
#endif #endif

35
common/include/r_data.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_data.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_data.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,26 +44,30 @@
ekr@rtfm.com Wed Feb 10 14:18:19 1999 ekr@rtfm.com Wed Feb 10 14:18:19 1999
*/ */
#ifndef _r_data_h #ifndef _r_data_h
#define _r_data_h #define _r_data_h
typedef struct Data_ { typedef struct Data_ {
UCHAR *data; UCHAR *data;
int len; int len;
} Data; } Data;
int r_data_create PROTO_LIST((Data **dp,UCHAR *d,int l)); int r_data_create PROTO_LIST((Data * *dp, UCHAR *d, int l));
int r_data_alloc PROTO_LIST((Data **dp, int l)); int r_data_alloc PROTO_LIST((Data * *dp, int l));
int r_data_make PROTO_LIST((Data *dp, UCHAR *d,int l)); int r_data_make PROTO_LIST((Data * dp, UCHAR *d, int l));
int r_data_destroy PROTO_LIST((Data **dp)); int r_data_destroy PROTO_LIST((Data * *dp));
int r_data_copy PROTO_LIST((Data *dst,Data *src)); int r_data_copy PROTO_LIST((Data * dst, Data *src));
int r_data_zfree PROTO_LIST((Data *d)); int r_data_zfree PROTO_LIST((Data * d));
int r_data_compare PROTO_LIST((Data *d1,Data *d2)); int r_data_compare PROTO_LIST((Data * d1, Data *d2));
#define INIT_DATA(a,b,c) (a).data=b; (a).len=c #define INIT_DATA(a, b, c) \
#define ATTACH_DATA(a,b) (a).data=b; (a).len=sizeof(b) (a).data = b; \
#define ZERO_DATA(a) (a).data=0; (a).len=0 (a).len = c
#define ATTACH_DATA(a, b) \
(a).data = b; \
(a).len = sizeof(b)
#define ZERO_DATA(a) \
(a).data = 0; \
(a).len = 0
#endif #endif

6
common/include/r_defaults.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_defaults.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_defaults.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Tue Dec 22 10:39:14 1998 ekr@rtfm.com Tue Dec 22 10:39:14 1998
*/ */
#ifndef _r_defaults_h #ifndef _r_defaults_h
#define _r_defaults_h #define _r_defaults_h
@ -51,9 +51,7 @@
#define R_USE_PROTOTYPES 1 #define R_USE_PROTOTYPES 1
#endif #endif
/*The needs defines don't belong here*/ /*The needs defines don't belong here*/
#define R_NEEDS_STDLIB_H #define R_NEEDS_STDLIB_H
#endif #endif

23
common/include/r_errors.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_errors.h,v 1.3 2002/01/21 17:36:51 ekr Exp $ $Id: r_errors.h,v 1.3 2002/01/21 17:36:51 ekr Exp $
@ -43,20 +44,18 @@
ekr@rtfm.com Tue Dec 22 10:59:49 1998 ekr@rtfm.com Tue Dec 22 10:59:49 1998
*/ */
#ifndef _r_errors_h #ifndef _r_errors_h
#define _r_errors_h #define _r_errors_h
#define R_NO_MEMORY 1 /*out of memory*/ #define R_NO_MEMORY 1 /*out of memory*/
#define R_NOT_FOUND 2 /*Item not found*/ #define R_NOT_FOUND 2 /*Item not found*/
#define R_INTERNAL 3 /*Unspecified internal error*/ #define R_INTERNAL 3 /*Unspecified internal error*/
#define R_ALREADY 4 /*Action already done*/ #define R_ALREADY 4 /*Action already done*/
#define R_EOD 5 /*end of data*/ #define R_EOD 5 /*end of data*/
#define R_BAD_ARGS 6 /*Bad arguments*/ #define R_BAD_ARGS 6 /*Bad arguments*/
#define R_BAD_DATA 7 /*Bad data*/ #define R_BAD_DATA 7 /*Bad data*/
#define R_WOULDBLOCK 8 /*Operation would block */ #define R_WOULDBLOCK 8 /*Operation would block */
int verr_exit PROTO_LIST((char *fmt,...)); int verr_exit PROTO_LIST((char *fmt, ...));
#endif #endif

5
common/include/r_includes.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_includes.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_includes.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Tue Dec 22 11:38:50 1998 ekr@rtfm.com Tue Dec 22 11:38:50 1998
*/ */
#ifndef _r_includes_h #ifndef _r_includes_h
#define _r_includes_h #define _r_includes_h
@ -59,4 +59,3 @@
#include <string.h> #include <string.h>
#endif #endif

32
common/include/r_list.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_list.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_list.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,27 +44,28 @@
ekr@rtfm.com Tue Jan 19 08:36:48 1999 ekr@rtfm.com Tue Jan 19 08:36:48 1999
*/ */
#ifndef _r_list_h #ifndef _r_list_h
#define _r_list_h #define _r_list_h
typedef struct r_list_ r_list; typedef struct r_list_ r_list;
typedef struct r_list_iterator_ { typedef struct r_list_iterator_ {
r_list *list; r_list *list;
struct r_list_el_ *ptr; struct r_list_el_ *ptr;
} r_list_iterator; } r_list_iterator;
int r_list_create PROTO_LIST((r_list **listp)); int r_list_create PROTO_LIST((r_list * *listp));
int r_list_destroy PROTO_LIST((r_list **listp)); int r_list_destroy PROTO_LIST((r_list * *listp));
int r_list_copy PROTO_LIST((r_list **out,r_list *in)); int r_list_copy PROTO_LIST((r_list * *out, r_list *in));
int r_list_insert PROTO_LIST((r_list *list,void *value, int r_list_insert PROTO_LIST((r_list * list,
int (*copy)(void **new,void *old), void *value,
int (*destroy)(void **ptr))); int (*copy)(void **new, void *old),
int r_list_append PROTO_LIST((r_list *list,void *value, int (*destroy)(void **ptr)));
int (*copy)(void **new,void *old), int r_list_append PROTO_LIST((r_list * list,
int (*destroy)(void **ptr))); void *value,
int r_list_init_iter PROTO_LIST((r_list *list,r_list_iterator *iter)); int (*copy)(void **new, void *old),
int r_list_iter PROTO_LIST((r_list_iterator *iter,void **val)); int (*destroy)(void **ptr)));
int r_list_init_iter PROTO_LIST((r_list * list, r_list_iterator *iter));
int r_list_iter PROTO_LIST((r_list_iterator * iter, void **val));
#endif #endif

60
common/include/r_macros.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_macros.h,v 1.4 2001/11/20 17:45:18 ekr Exp $ $Id: r_macros.h,v 1.4 2001/11/20 17:45:18 ekr Exp $
@ -43,11 +44,10 @@
ekr@rtfm.com Tue Dec 22 10:37:32 1998 ekr@rtfm.com Tue Dec 22 10:37:32 1998
*/ */
#ifndef _r_macros_h #ifndef _r_macros_h
#define _r_macros_h #define _r_macros_h
#if (R_USE_PROTOTYPES==1) #if(R_USE_PROTOTYPES == 1)
#define PROTO_LIST(a) a #define PROTO_LIST(a) a
#else #else
#define PROTO_LIST(a) () #define PROTO_LIST(a) ()
@ -58,34 +58,52 @@
#endif #endif
#ifdef R_TRACE_ERRORS #ifdef R_TRACE_ERRORS
#define REPORT_ERROR_(caller,a) fprintf(stderr,"%s: error %d at %s:%d (function %s)\n", \ #define REPORT_ERROR_(caller, a) \
caller,a,__FILE__,__LINE__,__FUNCTION__) fprintf(stderr, "%s: error %d at %s:%d (function %s)\n", caller, a, \
__FILE__, __LINE__, __FUNCTION__)
#else #else
#define REPORT_ERROR_(caller,a) #define REPORT_ERROR_(caller, a)
#endif #endif
#ifndef ERETURN #ifndef ERETURN
#define ERETURN(a) do {int _r=a; if(!_r) _r=-1; REPORT_ERROR_("ERETURN",_r); return(_r);} while(0) #define ERETURN(a) \
do { \
int _r = a; \
if(!_r) \
_r = -1; \
REPORT_ERROR_("ERETURN", _r); \
return (_r); \
} while(0)
#endif #endif
#ifndef ABORT #ifndef ABORT
#define ABORT(a) do { int _r=a; if(!_r) _r=-1; REPORT_ERROR_("ABORT",_r); _status=_r; goto abort;} while(0) #define ABORT(a) \
do { \
int _r = a; \
if(!_r) \
_r = -1; \
REPORT_ERROR_("ABORT", _r); \
_status = _r; \
goto abort; \
} while(0)
#endif #endif
#ifndef FREE #ifndef FREE
#define FREE(a) if(a) free(a) #define FREE(a) \
if(a) \
free(a)
#endif #endif
#ifndef MIN #ifndef MIN
#define MIN(a,b) (((a)>(b))?(b):(a)) #define MIN(a, b) (((a) > (b)) ? (b) : (a))
#endif #endif
#ifndef MAX #ifndef MAX
#define MAX(a,b) (((b)>(a))?(b):(a)) #define MAX(a, b) (((b) > (a)) ? (b) : (a))
#endif #endif
#ifdef DEBUG #ifdef DEBUG
#define DBG(a) debug a #define DBG(a) debug a
int debug(int class,char *format,...); int debug(int class, char *format, ...);
#else #else
#define DBG(a) #define DBG(a)
#endif #endif
@ -95,18 +113,24 @@ int debug(int class,char *format,...);
#endif #endif
#ifndef RCALLOC #ifndef RCALLOC
#define RCALLOC(a) calloc(1,a) #define RCALLOC(a) calloc(1, a)
#endif #endif
#ifndef RFREE #ifndef RFREE
#define RFREE(a) if(a) free(a) #define RFREE(a) \
if(a) \
free(a)
#endif #endif
#ifndef RREALLOC #ifndef RREALLOC
#define RREALLOC(a,b) realloc(a,b) #define RREALLOC(a, b) realloc(a, b)
#endif #endif
#define UNIMPLEMENTED do { fprintf(stderr,"Function %s unimplemented\n",__FUNCTION__); abort(); } while(0) #define UNIMPLEMENTED \
do { \
fprintf(stderr, "Function %s unimplemented\n", __FUNCTION__); \
abort(); \
} while(0)
#ifdef STDC_HEADERS #ifdef STDC_HEADERS
#include <string.h> #include <string.h>
@ -115,9 +139,9 @@ int debug(int class,char *format,...);
#ifndef STRNICMP #ifndef STRNICMP
#ifdef _WIN32 #ifdef _WIN32
#define STRNICMP(a,b,n) strnicmp(a,b,n) #define STRNICMP(a, b, n) strnicmp(a, b, n)
#else #else
#define STRNICMP(a,b,n) strncasecmp(a,b,n) #define STRNICMP(a, b, n) strncasecmp(a, b, n)
#endif #endif
#endif #endif

14
common/include/r_thread.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_thread.h,v 1.2 2000/10/17 16:09:59 ekr Exp $ $Id: r_thread.h,v 1.2 2000/10/17 16:09:59 ekr Exp $
@ -43,27 +44,24 @@
ekr@rtfm.com Tue Feb 23 14:58:36 1999 ekr@rtfm.com Tue Feb 23 14:58:36 1999
*/ */
#ifndef _r_thread_h #ifndef _r_thread_h
#define _r_thread_h #define _r_thread_h
typedef void *r_thread; typedef void *r_thread;
typedef void *r_rwlock; typedef void *r_rwlock;
int r_thread_fork PROTO_LIST((void (*func)(void *),void *arg, int r_thread_fork PROTO_LIST((void (*func)(void *), void *arg, r_thread *tid));
r_thread *tid));
int r_thread_destroy PROTO_LIST((r_thread tid)); int r_thread_destroy PROTO_LIST((r_thread tid));
int r_thread_yield PROTO_LIST((void)); int r_thread_yield PROTO_LIST((void));
int r_thread_exit PROTO_LIST((void)); int r_thread_exit PROTO_LIST((void));
int r_thread_wait_last PROTO_LIST((void)); int r_thread_wait_last PROTO_LIST((void));
int r_rwlock_create PROTO_LIST((r_rwlock **lockp)); int r_rwlock_create PROTO_LIST((r_rwlock * *lockp));
int r_rwlock_destroy PROTO_LIST((r_rwlock **lock)); int r_rwlock_destroy PROTO_LIST((r_rwlock * *lock));
int r_rwlock_lock PROTO_LIST((r_rwlock *lock,int action)); int r_rwlock_lock PROTO_LIST((r_rwlock * lock, int action));
#define R_RWLOCK_UNLOCK 0 #define R_RWLOCK_UNLOCK 0
#define R_RWLOCK_RLOCK 1 #define R_RWLOCK_RLOCK 1
#define R_RWLOCK_WLOCK 2 #define R_RWLOCK_WLOCK 2
#endif #endif

39
common/include/r_time.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_time.h,v 1.4 2001/12/24 06:06:26 ekr Exp $ $Id: r_time.h,v 1.4 2001/12/24 06:06:26 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Thu Mar 4 08:45:41 1999 ekr@rtfm.com Thu Mar 4 08:45:41 1999
*/ */
#ifndef _r_time_h #ifndef _r_time_h
#define _r_time_h #define _r_time_h
@ -52,28 +52,29 @@
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
# include <winsock2.h> #include <winsock2.h>
#else #else
/* Cribbed from the autoconf doc */ /* Cribbed from the autoconf doc */
# if TIME_WITH_SYS_TIME #if TIME_WITH_SYS_TIME
# include <sys/time.h> #include <sys/time.h>
# include <time.h> #include <time.h>
# else #else
# if HAVE_SYS_TIME_H #if HAVE_SYS_TIME_H
# include <sys/time.h> #include <sys/time.h>
# else #else
# include <time.h> #include <time.h>
# endif #endif
# endif #endif
#endif #endif
int r_timeval_diff PROTO_LIST((struct timeval *t1,struct timeval *t0, int r_timeval_diff PROTO_LIST((struct timeval * t1,
struct timeval *diff)); struct timeval *t0,
int r_timeval_add PROTO_LIST((struct timeval *t1,struct timeval *t2, struct timeval *diff));
struct timeval *sum)); int r_timeval_add PROTO_LIST((struct timeval * t1,
struct timeval *t2,
struct timeval *sum));
UINT8 r_timeval2int PROTO_LIST((struct timeval *tv)); UINT8 r_timeval2int PROTO_LIST((struct timeval * tv));
UINT8 r_gettimeint PROTO_LIST((void)); UINT8 r_gettimeint PROTO_LIST((void));
#endif #endif

33
common/include/r_types.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_types.h,v 1.3 2002/09/09 21:02:58 ekr Exp $ $Id: r_types.h,v 1.3 2002/09/09 21:02:58 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Tue Dec 22 10:36:02 1998 ekr@rtfm.com Tue Dec 22 10:36:02 1998
*/ */
#ifndef _r_types_h #ifndef _r_types_h
#define _r_types_h #define _r_types_h
@ -55,15 +55,15 @@
#ifndef SIZEOF_UNSIGNED_INT #ifndef SIZEOF_UNSIGNED_INT
typedef unsigned int UINT4; typedef unsigned int UINT4;
#else #else
# if (SIZEOF_UNSIGNED_INT==4) #if(SIZEOF_UNSIGNED_INT == 4)
typedef unsigned int UINT4; typedef unsigned int UINT4;
# elif (SIZEOF_UNSIGNED_SHORT==4) #elif(SIZEOF_UNSIGNED_SHORT == 4)
typedef unsigned short UINT4; typedef unsigned short UINT4;
# elif (SIZEOF_UNSIGNED_LONG==4) #elif(SIZEOF_UNSIGNED_LONG == 4)
typedef unsigned long UINT4; typedef unsigned long UINT4;
# else #else
# error no type for UINT4 #error no type for UINT4
# endif #endif
#endif #endif
#endif #endif
@ -71,19 +71,19 @@ typedef unsigned long UINT4;
#ifndef SIZEOF_UNSIGNED_LONG #ifndef SIZEOF_UNSIGNED_LONG
typedef unsigned long UINT8; typedef unsigned long UINT8;
#else #else
# if (SIZEOF_UNSIGNED_INT==8) #if(SIZEOF_UNSIGNED_INT == 8)
typedef unsigned int UINT8; typedef unsigned int UINT8;
# elif (SIZEOF_UNSIGNED_SHORT==8) #elif(SIZEOF_UNSIGNED_SHORT == 8)
typedef unsigned short UINT8; typedef unsigned short UINT8;
# elif (SIZEOF_UNSIGNED_LONG==8) #elif(SIZEOF_UNSIGNED_LONG == 8)
typedef unsigned long UINT8; typedef unsigned long UINT8;
# elif (SIZEOF_UNSIGNED_LONG_LONG==8) #elif(SIZEOF_UNSIGNED_LONG_LONG == 8)
typedef unsigned long long UINT8; typedef unsigned long long UINT8;
# elif defined (_WIN32) && defined (_MSC_VER) #elif defined(_WIN32) && defined(_MSC_VER)
typedef unsigned __int64 UINT8; typedef unsigned __int64 UINT8;
# else #else
# error no type for UINT8 #error no type for UINT8
# endif #endif
#endif #endif
#endif #endif
@ -92,4 +92,3 @@ typedef unsigned char UCHAR;
#endif #endif
#endif #endif

5
common/lib/assoc.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: assoc.h,v 1.2 2000/10/17 16:10:00 ekr Exp $ $Id: assoc.h,v 1.2 2000/10/17 16:10:00 ekr Exp $
@ -43,11 +44,9 @@
ekr@rtfm.com Sun Jan 17 17:56:35 1999 ekr@rtfm.com Sun Jan 17 17:56:35 1999
*/ */
#ifndef _assoc_h #ifndef _assoc_h
#define _assoc_h #define _assoc_h
typedef struct assoc_ assoc; typedef struct assoc_ assoc;
#endif #endif

62
common/lib/debug.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: debug.c,v 1.3 2001/12/24 06:06:26 ekr Exp $ $Id: debug.c,v 1.3 2001/12/24 06:06:26 ekr Exp $
@ -43,49 +44,34 @@
ekr@rtfm.com Wed Jan 6 17:08:58 1999 ekr@rtfm.com Wed Jan 6 17:08:58 1999
*/ */
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include "r_common.h" #include "r_common.h"
#include "debug.h" #include "debug.h"
int debug(int class,char *format,...) int debug(int class, char *format, ...) {
{ va_list ap;
va_list ap;
va_start(ap,format); va_start(ap, format);
vfprintf(stderr,format,ap); vfprintf(stderr, format, ap);
fprintf(stderr,"\n"); fprintf(stderr, "\n");
va_end(ap); va_end(ap);
return(0); return (0);
}
int xdump(char *name, UCHAR *data, int len) {
int i;
if(name) {
printf("%s[%d]=\n", name, len);
} }
for(i = 0; i < len; i++) {
int xdump(name,data,len) if((len > 8) && i && !(i % 12)) {
char *name;
UCHAR *data;
int len;
{
int i;
if(name){
printf("%s[%d]=\n",name,len);
}
for(i=0;i<len;i++){
if((len>8) && i && !(i%12)){
printf("\n");
}
printf("%.2x ",data[i]&255);
}
if(i%12)
printf("\n"); printf("\n");
return(0); }
printf("%.2x ", data[i] & 255);
} }
if(i % 12)
printf("\n");
return (0);
}

10
common/lib/debug.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: debug.h,v 1.3 2001/12/24 06:06:26 ekr Exp $ $Id: debug.h,v 1.3 2001/12/24 06:06:26 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Wed Jan 6 17:13:00 1999 ekr@rtfm.com Wed Jan 6 17:13:00 1999
*/ */
#ifndef _debug_h #ifndef _debug_h
#define _debug_h #define _debug_h
@ -53,9 +53,7 @@
#define DBG(a) #define DBG(a)
#endif #endif
int debug(int class,char *format,...); int debug(int class, char *format, ...);
int xdump PROTO_LIST((char *name,UCHAR *data, int xdump PROTO_LIST((char *name, UCHAR *data, int len));
int len));
#endif #endif

614
common/lib/r_assoc.c
View file

@ -46,7 +46,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_assoc.c,v 1.4 2001/12/24 06:06:26 ekr Exp $ $Id: r_assoc.c,v 1.4 2001/12/24 06:06:26 ekr Exp $
@ -54,374 +55,331 @@
ekr@rtfm.com Sun Jan 17 17:57:15 1999 ekr@rtfm.com Sun Jan 17 17:57:15 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include "r_assoc.h" #include "r_assoc.h"
typedef struct r_assoc_el_ { typedef struct r_assoc_el_ {
char *key; char *key;
int key_len; int key_len;
void *data; void *data;
struct r_assoc_el_ *prev; struct r_assoc_el_ *prev;
struct r_assoc_el_ *next; struct r_assoc_el_ *next;
int (*copy) PROTO_LIST((void **new,void *old)); int(*copy) PROTO_LIST((void **new, void *old));
int (*destroy) PROTO_LIST((void *ptr)); int(*destroy) PROTO_LIST((void *ptr));
} r_assoc_el; } r_assoc_el;
struct r_assoc_ { struct r_assoc_ {
int size; int size;
int bits; int bits;
r_assoc_el **chains; r_assoc_el **chains;
}; };
#define DEFAULT_TABLE_BITS 5 #define DEFAULT_TABLE_BITS 5
static int destroy_assoc_chain PROTO_LIST((r_assoc_el *chain)); static int destroy_assoc_chain PROTO_LIST((r_assoc_el * chain));
static int r_assoc_fetch_bucket PROTO_LIST((r_assoc *assoc, static int r_assoc_fetch_bucket
char *key,int len,r_assoc_el **bucketp)); PROTO_LIST((r_assoc * assoc, char *key, int len, r_assoc_el **bucketp));
UINT4 hash_compute PROTO_LIST((char *key,int len,int size)); UINT4 hash_compute PROTO_LIST((char *key, int len, int size));
static int copy_assoc_chain PROTO_LIST((r_assoc_el **newp, static int copy_assoc_chain PROTO_LIST((r_assoc_el * *newp, r_assoc_el *old));
r_assoc_el *old));
int r_assoc_create(assocp) int r_assoc_create(r_assoc **assocp) {
r_assoc **assocp; r_assoc *assoc = 0;
{ int _status;
r_assoc *assoc=0;
int _status;
if(!(assoc=(r_assoc *)calloc(sizeof(r_assoc),1))) if(!(assoc = (r_assoc *)calloc(sizeof(r_assoc), 1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
assoc->size=(1<<DEFAULT_TABLE_BITS); assoc->size = (1 << DEFAULT_TABLE_BITS);
assoc->bits=DEFAULT_TABLE_BITS; assoc->bits = DEFAULT_TABLE_BITS;
if(!(assoc->chains=(r_assoc_el **)calloc(sizeof(r_assoc_el *), if(!(assoc->chains =
assoc->size))) (r_assoc_el **)calloc(sizeof(r_assoc_el *), assoc->size)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
*assocp=assoc; *assocp = assoc;
_status=0; _status = 0;
abort: abort:
if(_status){ if(_status) {
r_assoc_destroy(&assoc); r_assoc_destroy(&assoc);
}
return(_status);
} }
return (_status);
}
int r_assoc_destroy(assocp) int r_assoc_destroy(r_assoc **assocp) {
r_assoc **assocp;
{
r_assoc *assoc;
int i;
if(!assocp || !*assocp)
return(0);
assoc=*assocp;
for(i=0;i<assoc->size;i++)
destroy_assoc_chain(assoc->chains[i]);
free(assoc->chains);
free(assoc);
return(0);
}
static int destroy_assoc_chain(chain)
r_assoc_el *chain;
{
r_assoc_el *nxt;
while(chain){
nxt=chain->next;
if(chain->destroy)
chain->destroy(chain->data);
free(chain->key);
free(chain);
chain=nxt;
}
return(0);
}
static int copy_assoc_chain(newp,old)
r_assoc_el **newp;
r_assoc_el *old;
{
r_assoc_el *new=0,*ptr,*tmp;
int r,_status;
if(!old) {
*newp=0;
return(0);
}
for(;old;old=old->next){
if(!(tmp=(r_assoc_el *)calloc(sizeof(r_assoc_el),1)))
ABORT(R_NO_MEMORY);
if(!new){
new=tmp;
ptr=new;
}
else{
ptr->next=tmp;
tmp->prev=ptr;
ptr=tmp;
}
ptr->destroy=old->destroy;
ptr->copy=old->copy;
if(old->copy){
if((r=old->copy(&ptr->data,old->data)))
ABORT(r);
}
else
ptr->data=old->data;
if(!(ptr->key=(char *)malloc(old->key_len)))
ABORT(R_NO_MEMORY);
memcpy(ptr->key,old->key,ptr->key_len=old->key_len);
}
*newp=new;
_status=0;
abort:
if(_status){
destroy_assoc_chain(new);
}
return(_status);
}
static int r_assoc_fetch_bucket(assoc,key,len,bucketp)
r_assoc *assoc; r_assoc *assoc;
char *key; int i;
int len;
r_assoc_el **bucketp; if(!assocp || !*assocp)
{ return (0);
assoc = *assocp;
for(i = 0; i < assoc->size; i++)
destroy_assoc_chain(assoc->chains[i]);
free(assoc->chains);
free(assoc);
return (0);
}
static int destroy_assoc_chain(r_assoc_el *chain) {
r_assoc_el *nxt;
while(chain) {
nxt = chain->next;
if(chain->destroy)
chain->destroy(chain->data);
free(chain->key);
free(chain);
chain = nxt;
}
return (0);
}
static int copy_assoc_chain(r_assoc_el **newp, r_assoc_el *old) {
r_assoc_el *new = 0, *ptr, *tmp;
int r, _status;
if(!old) {
*newp = 0;
return (0);
}
for(; old; old = old->next) {
if(!(tmp = (r_assoc_el *)calloc(sizeof(r_assoc_el), 1)))
ABORT(R_NO_MEMORY);
if(!new) {
new = tmp;
ptr = new;
} else {
ptr->next = tmp;
tmp->prev = ptr;
ptr = tmp;
}
ptr->destroy = old->destroy;
ptr->copy = old->copy;
if(old->copy) {
if((r = old->copy(&ptr->data, old->data)))
ABORT(r);
} else
ptr->data = old->data;
if(!(ptr->key = (char *)malloc(old->key_len)))
ABORT(R_NO_MEMORY);
memcpy(ptr->key, old->key, ptr->key_len = old->key_len);
}
*newp = new;
_status = 0;
abort:
if(_status) {
destroy_assoc_chain(new);
}
return (_status);
}
static int r_assoc_fetch_bucket(r_assoc *assoc,
char *key,
int len,
r_assoc_el **bucketp) {
UINT4 hash_value;
r_assoc_el *bucket;
hash_value = hash_compute(key, len, assoc->bits);
for(bucket = assoc->chains[hash_value]; bucket; bucket = bucket->next) {
if(bucket->key_len == len && !memcmp(bucket->key, key, len)) {
*bucketp = bucket;
return (0);
}
}
return (R_NOT_FOUND);
}
int r_assoc_fetch(r_assoc *assoc, char *key, int len, void **datap) {
r_assoc_el *bucket;
int r;
if((r = r_assoc_fetch_bucket(assoc, key, len, &bucket))) {
if(r != R_NOT_FOUND)
ERETURN(r);
return (r);
}
*datap = bucket->data;
return (0);
}
int r_assoc_insert(r_assoc *assoc,
char *key,
int len,
void *data,
int(*copy) PROTO_LIST((void **new, void *old)),
int(*destroy) PROTO_LIST((void *ptr)),
int how) {
r_assoc_el *bucket, *new_bucket = 0;
int r, _status;
if((r = r_assoc_fetch_bucket(assoc, key, len, &bucket))) {
/*Note that we compute the hash value twice*/
UINT4 hash_value; UINT4 hash_value;
r_assoc_el *bucket;
hash_value=hash_compute(key,len,assoc->bits); if(r != R_NOT_FOUND)
ABORT(r);
hash_value = hash_compute(key, len, assoc->bits);
for(bucket=assoc->chains[hash_value];bucket;bucket=bucket->next){ if(!(new_bucket = (r_assoc_el *)calloc(sizeof(r_assoc_el), 1)))
if(bucket->key_len == len && !memcmp(bucket->key,key,len)){
*bucketp=bucket;
return(0);
}
}
return(R_NOT_FOUND);
}
int r_assoc_fetch(assoc,key,len,datap)
r_assoc *assoc;
char *key;
int len;
void **datap;
{
r_assoc_el *bucket;
int r;
if((r=r_assoc_fetch_bucket(assoc,key,len,&bucket))){
if(r!=R_NOT_FOUND)
ERETURN(r);
return(r);
}
*datap=bucket->data;
return(0);
}
int r_assoc_insert(assoc,key,len,data,copy,destroy,how)
r_assoc *assoc;
char *key;
int len;
void *data;
int (*copy) PROTO_LIST((void **new,void *old));
int (*destroy) PROTO_LIST((void *ptr));
int how;
{
r_assoc_el *bucket,*new_bucket=0;
int r,_status;
if((r=r_assoc_fetch_bucket(assoc,key,len,&bucket))){
/*Note that we compute the hash value twice*/
UINT4 hash_value;
if(r!=R_NOT_FOUND)
ABORT(r);
hash_value=hash_compute(key,len,assoc->bits);
if(!(new_bucket=(r_assoc_el *)calloc(sizeof(r_assoc_el),1)))
ABORT(R_NO_MEMORY);
if(!(new_bucket->key=(char *)malloc(len)))
ABORT(R_NO_MEMORY);
memcpy(new_bucket->key,key,len);
new_bucket->key_len=len;
/*Insert at the list head. Is FIFO a good algorithm?*/
if(assoc->chains[hash_value])
assoc->chains[hash_value]->prev=new_bucket;
new_bucket->next=assoc->chains[hash_value];
assoc->chains[hash_value]=new_bucket;
bucket=new_bucket;
}
else{
if(!(how&R_ASSOC_REPLACE))
ABORT(R_ALREADY);
if(bucket->destroy)
bucket->destroy(bucket->data);
}
bucket->data=data;
bucket->copy=copy;
bucket->destroy=destroy;
_status=0;
abort:
if(_status && new_bucket){
free(new_bucket->key);
free(new_bucket);
}
return(_status);
}
int r_assoc_copy(newp,old)
r_assoc **newp;
r_assoc *old;
{
int r,_status,i;
r_assoc *new;
if(!(new=(r_assoc *)calloc(sizeof(r_assoc),1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
new->size=old->size; if(!(new_bucket->key = (char *)malloc(len)))
new->bits=old->bits;
if(!(new->chains=(r_assoc_el **)calloc(sizeof(r_assoc_el),old->size)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
for(i=0;i<new->size;i++){ memcpy(new_bucket->key, key, len);
if((r=copy_assoc_chain(new->chains+i,old->chains[i]))) new_bucket->key_len = len;
ABORT(R_NO_MEMORY);
}
*newp=new;
_status=0; /*Insert at the list head. Is FIFO a good algorithm?*/
abort: if(assoc->chains[hash_value])
if(_status){ assoc->chains[hash_value]->prev = new_bucket;
r_assoc_destroy(&new); new_bucket->next = assoc->chains[hash_value];
} assoc->chains[hash_value] = new_bucket;
return(_status); bucket = new_bucket;
} else {
if(!(how & R_ASSOC_REPLACE))
ABORT(R_ALREADY);
if(bucket->destroy)
bucket->destroy(bucket->data);
} }
int r_assoc_init_iter(assoc,iter) bucket->data = data;
r_assoc *assoc; bucket->copy = copy;
r_assoc_iterator *iter; bucket->destroy = destroy;
{
int i;
iter->assoc=assoc; _status = 0;
iter->prev_chain=-1; abort:
iter->prev=0; if(_status && new_bucket) {
free(new_bucket->key);
free(new_bucket);
}
return (_status);
}
iter->next_chain=assoc->size; int r_assoc_copy(r_assoc **newp, r_assoc *old) {
iter->next=0; int r, _status, i;
r_assoc *new;
for(i=0;i<assoc->size;i++){ if(!(new = (r_assoc *)calloc(sizeof(r_assoc), 1)))
if(assoc->chains[i]!=0){ ABORT(R_NO_MEMORY);
iter->next_chain=i; new->size = old->size;
iter->next=assoc->chains[i]; new->bits = old->bits;
break;
if(!(new->chains = (r_assoc_el **)calloc(sizeof(r_assoc_el), old->size)))
ABORT(R_NO_MEMORY);
for(i = 0; i < new->size; i++) {
if((r = copy_assoc_chain(new->chains + i, old->chains[i])))
ABORT(R_NO_MEMORY);
}
*newp = new;
_status = 0;
abort:
if(_status) {
r_assoc_destroy(&new);
}
return (_status);
}
int r_assoc_init_iter(r_assoc *assoc, r_assoc_iterator *iter) {
int i;
iter->assoc = assoc;
iter->prev_chain = -1;
iter->prev = 0;
iter->next_chain = assoc->size;
iter->next = 0;
for(i = 0; i < assoc->size; i++) {
if(assoc->chains[i] != 0) {
iter->next_chain = i;
iter->next = assoc->chains[i];
break;
}
}
return (0);
}
int r_assoc_iter(r_assoc_iterator *iter, void **key, int *keyl, void **val) {
int i;
r_assoc_el *ret;
if(!iter->next)
return (R_EOD);
ret = iter->next;
*key = ret->key;
*keyl = ret->key_len;
*val = ret->data;
/* Now increment */
iter->prev_chain = iter->next_chain;
iter->prev = iter->next;
/* More on this chain */
if(iter->next->next) {
iter->next = iter->next->next;
} else {
iter->next = 0;
/* FInd the next occupied chain*/
for(i = iter->next_chain; i < iter->assoc->size; i++) {
if(iter->assoc->chains[i]) {
iter->next_chain = i;
iter->next = iter->assoc->chains[i];
break;
} }
} }
return(0);
} }
int r_assoc_iter(iter,key,keyl,val) return (0);
r_assoc_iterator *iter; }
void **key;
int *keyl;
void **val;
{
int i;
r_assoc_el *ret;
if(!iter->next)
return(R_EOD);
ret=iter->next;
*key=ret->key;
*keyl=ret->key_len;
*val=ret->data;
/* Now increment */
iter->prev_chain=iter->next_chain;
iter->prev=iter->next;
/* More on this chain */
if(iter->next->next){
iter->next=iter->next->next;
}
else{
iter->next=0;
/* FInd the next occupied chain*/
for(i=iter->next_chain;i<iter->assoc->size;i++){
if(iter->assoc->chains[i]){
iter->next_chain=i;
iter->next=iter->assoc->chains[i];
break;
}
}
}
return(0);
}
/* Delete the last returned value*/ /* Delete the last returned value*/
int r_assoc_iter_delete(iter) int r_assoc_iter_delete(r_assoc_iterator *iter) {
r_assoc_iterator *iter; /* First unhook it from the list*/
{ if(!iter->prev->prev) {
/* First unhook it from the list*/ /* First element*/
if(!iter->prev->prev){ iter->assoc->chains[iter->prev_chain] = iter->prev->next;
/* First element*/ } else {
iter->assoc->chains[iter->prev_chain]=iter->prev->next; iter->prev->prev->next = iter->prev->next;
}
else{
iter->prev->prev->next=iter->prev->next;
}
if(iter->prev->next){
iter->prev->next->prev=iter->prev->prev;
}
iter->prev->destroy(iter->prev->data);
free(iter->prev->data);
free(iter->prev);
return(0);
} }
if(iter->prev->next) {
iter->prev->next->prev = iter->prev->prev;
}
iter->prev->destroy(iter->prev->data);
free(iter->prev->data);
free(iter->prev);
return (0);
}
/*This is a hack from AMS. Supposedly, it's pretty good for strings, even /*This is a hack from AMS. Supposedly, it's pretty good for strings, even
though it doesn't take into account all the data*/ though it doesn't take into account all the data*/
UINT4 hash_compute(key,len,bits) UINT4
char *key; hash_compute(char *key, int len, int bits) {
int len; UINT4 h = 0;
int bits;
{
UINT4 h=0;
h=key[0] +(key[len-1] * len); h = key[0] + (key[len - 1] * len);
h &= (1<<bits) - 1; h &= (1 << bits) - 1;
return(h);
}
return (h);
}

144
common/lib/r_assoc_test.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_assoc_test.c,v 1.2 2000/10/17 16:10:00 ekr Exp $ $Id: r_assoc_test.c,v 1.2 2000/10/17 16:10:00 ekr Exp $
@ -43,94 +44,85 @@
ekr@rtfm.com Sun Jan 17 21:09:22 1999 ekr@rtfm.com Sun Jan 17 21:09:22 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include <r_assoc.h> #include <r_assoc.h>
int main() int main(void) {
{ char test_vector[1024], *v;
char test_vector[1024],*v; int rnd, ct, r;
int rnd,ct,r; r_assoc *assoc, *new_assoc;
r_assoc *assoc,*new_assoc;
if(r=r_assoc_create(&assoc)){ if(r = r_assoc_create(&assoc)) {
fprintf(stderr,"Couldn't create\n"); fprintf(stderr, "Couldn't create\n");
exit(1);
}
srand(getpid());
v = test_vector;
for(ct = 0; ct < 256; ct++) {
v[0] = ct & 255;
v[1] = (ct >> 8) & 255;
v[2] = (ct >> 16) & 255;
v[3] = (ct >> 24) & 255;
if(r = r_assoc_insert(assoc, v, 4, v, 0, 0, R_ASSOC_REPLACE)) {
fprintf(stderr, "Couldn't insert %d\n", ct);
exit(1); exit(1);
} }
srand(getpid()); v += 4;
}
v=test_vector; fetch_test(assoc);
for(ct=0;ct<256;ct++){
v[0]=ct & 255;
v[1]=(ct>>8) & 255;
v[2]=(ct>>16) & 255;
v[3]=(ct>>24) & 255;
if(r = r_assoc_copy(&new_assoc, assoc)) {
fprintf(stderr, "Couldn't copy\n");
exit(1);
}
if(r=r_assoc_insert(assoc,v,4,v,0,0,R_ASSOC_REPLACE)){ r_assoc_destroy(&assoc);
fprintf(stderr,"Couldn't insert %d\n",ct);
exit(1); fetch_test(new_assoc);
r_assoc_destroy(&new_assoc);
printf("Tests pass\n");
exit(0);
}
int fetch_test(r_assoc *assoc) {
int ct;
char vec[4], *v;
int r, _status, rnd;
for(ct = 0; ct < 65537; ct++) {
rnd = rand();
rnd &= 0x3ff;
vec[0] = rnd & 255;
vec[1] = (rnd >> 8) & 255;
vec[2] = (rnd >> 16) & 255;
vec[3] = (rnd >> 24) & 255;
if(r = r_assoc_fetch(assoc, vec, 4, (void **)&v)) {
if(rnd < 256) {
fprintf(stderr, "Couldn't fetch\n");
exit(1);
} else
continue;
} else {
if(rnd > 255) {
fprintf(stderr, "Spurious fetch\n");
exit(1);
} }
v+=4;
} }
fetch_test(assoc); if(memcmp(vec, v, 4)) {
fprintf(stderr, "Fetch error\n");
if(r=r_assoc_copy(&new_assoc,assoc)){
fprintf(stderr,"Couldn't copy\n");
exit(1); exit(1);
} }
r_assoc_destroy(&assoc);
fetch_test(new_assoc);
r_assoc_destroy(&new_assoc);
printf("Tests pass\n");
exit(0);
}
int fetch_test(assoc)
r_assoc *assoc;
{
int ct;
char vec[4],*v;
int r,_status,rnd;
for(ct=0;ct<65537;ct++){
rnd=rand();
rnd &= 0x3ff;
vec[0]=rnd & 255;
vec[1]=(rnd>>8) & 255;
vec[2]=(rnd>>16) & 255;
vec[3]=(rnd>>24) & 255;
if(r=r_assoc_fetch(assoc,vec,4,(void **)&v)){
if(rnd<256){
fprintf(stderr,"Couldn't fetch\n");
exit(1);
}
else
continue;
}
else{
if(rnd>255){
fprintf(stderr,"Spurious fetch\n");
exit(1);
}
}
if(memcmp(vec,v,4)){
fprintf(stderr,"Fetch error\n");
exit(1);
}
}
return(0);
} }
return (0);
}

145
common/lib/r_bitfield.c
View file

@ -7,103 +7,90 @@
ekr@rtfm.com Wed Oct 3 11:15:23 2001 ekr@rtfm.com Wed Oct 3 11:15:23 2001
*/ */
#include <r_common.h> #include <r_common.h>
#include "r_bitfield.h" #include "r_bitfield.h"
int r_bitfield_create(setp,size) int r_bitfield_create(r_bitfield **setp, UINT4 size) {
r_bitfield **setp; r_bitfield *set = 0;
UINT4 size; int _status;
{ int num_words = size / 32 + !!(size % 32);
r_bitfield *set=0;
int _status;
int num_words=size/32+!!(size%32);
if(!(set=(r_bitfield *)RMALLOC(sizeof(r_bitfield)))) if(!(set = (r_bitfield *)RMALLOC(sizeof(r_bitfield))))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
if(!(set->data=(UINT4 *)RMALLOC(num_words*4))) if(!(set->data = (UINT4 *)RMALLOC(num_words * 4)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
memset(set->data,0,4*num_words); memset(set->data, 0, 4 * num_words);
set->base=0; set->base = 0;
set->len=num_words; set->len = num_words;
*setp=set; *setp = set;
_status=0; _status = 0;
abort: abort:
if(_status){ if(_status) {
r_bitfield_destroy(&set); r_bitfield_destroy(&set);
}
return(_status);
} }
return (_status);
}
int r_bitfield_destroy(setp) int r_bitfield_destroy(r_bitfield **setp) {
r_bitfield **setp; r_bitfield *set;
{
r_bitfield *set;
if(!setp || !*setp) if(!setp || !*setp)
return(0); return (0);
set=*setp; set = *setp;
RFREE(set->data);
RFREE(set);
*setp = 0;
return (0);
}
int r_bitfield_set(r_bitfield *set, int bit) {
int word = (bit - set->base) / 32;
int bbit = (bit - set->base) % 32;
int _status;
/* Resize? */
if(word > set->len) {
UINT4 newlen = set->len;
UINT4 *tmp;
while(newlen < word)
newlen *= 2;
if(!(tmp = (UINT4 *)RMALLOC(newlen)))
ABORT(R_NO_MEMORY);
memcpy(tmp, set->data, set->len * 4);
memset(tmp + set->len * 4, 0, (newlen - set->len) * 4);
RFREE(set->data); RFREE(set->data);
RFREE(set); set->data = tmp;
*setp=0;
return(0);
} }
int r_bitfield_set(set,bit) set->data[word] |= 1 << bbit;
r_bitfield *set;
int bit;
{
int word=(bit-set->base)/32;
int bbit=(bit-set->base)%32;
int _status;
/* Resize? */ _status = 0;
if(word>set->len){ abort:
UINT4 newlen=set->len; return (_status);
UINT4 *tmp; }
while(newlen<word) int r_bitfield_isset(r_bitfield *set, int bit) {
newlen*=2; int word = (bit - set->base) / 32;
int bbit = (bit - set->base) % 32;
int _status;
if(!(tmp=(UINT4 *)RMALLOC(newlen))) if(bit < set->base)
ABORT(R_NO_MEMORY); return (0);
memcpy(tmp,set->data,set->len*4); /* Resize? */
memset(tmp+set->len*4,0,(newlen-set->len)*4); if(word > set->len)
return (0);
RFREE(set->data); return (set->data[word] & (1 << bbit));
set->data=tmp; }
}
set->data[word]|=1<<bbit;
_status=0;
abort:
return(_status);
}
int r_bitfield_isset(set,bit)
r_bitfield *set;
int bit;
{
int word=(bit-set->base)/32;
int bbit=(bit-set->base)%32;
int _status;
if(bit<set->base)
return(0);
/* Resize? */
if(word>set->len)
return(0);
return(set->data[word]&(1<<bbit));
}

165
common/lib/r_data.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_data.c,v 1.3 2001/07/20 23:33:15 ekr Exp $ $Id: r_data.c,v 1.3 2001/07/20 23:33:15 ekr Exp $
@ -43,119 +44,95 @@
ekr@rtfm.com Tue Aug 17 15:39:50 1999 ekr@rtfm.com Tue Aug 17 15:39:50 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include <r_data.h> #include <r_data.h>
int r_data_create(dp,d,l) int r_data_create(Data **dp, UCHAR *d, int l) {
Data **dp; Data *d_ = 0;
UCHAR *d; int _status;
int l;
{
Data *d_=0;
int _status;
if(!(d_=(Data *)calloc(sizeof(Data),1))) if(!(d_ = (Data *)calloc(sizeof(Data), 1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
if(!(d_->data=(UCHAR *)malloc(l))) if(!(d_->data = (UCHAR *)malloc(l)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
memcpy(d_->data,d,l); memcpy(d_->data, d, l);
d_->len=l; d_->len = l;
*dp=d_; *dp = d_;
_status=0; _status = 0;
abort: abort:
if(_status) if(_status)
r_data_destroy(&d_); r_data_destroy(&d_);
return(_status); return (_status);
} }
int r_data_alloc(dp,l) int r_data_alloc(Data **dp, int l) {
Data **dp; Data *d_ = 0;
int l; int _status;
{
Data *d_=0;
int _status;
if(!(d_=(Data *)calloc(sizeof(Data),1))) if(!(d_ = (Data *)calloc(sizeof(Data), 1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
if(!(d_->data=(UCHAR *)calloc(l,1))) if(!(d_->data = (UCHAR *)calloc(l, 1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
d_->len=l; d_->len = l;
*dp=d_; *dp = d_;
_status=0; _status = 0;
abort: abort:
if(_status) if(_status)
r_data_destroy(&d_); r_data_destroy(&d_);
return(_status); return (_status);
} }
int r_data_make(dp,d,l) int r_data_make(Data *dp, UCHAR *d, int l) {
Data *dp; if(!(dp->data = (UCHAR *)malloc(l)))
UCHAR *d; ERETURN(R_NO_MEMORY);
int l;
{
if(!(dp->data=(UCHAR *)malloc(l)))
ERETURN(R_NO_MEMORY);
memcpy(dp->data,d,l); memcpy(dp->data, d, l);
dp->len=l; dp->len = l;
return(0); return (0);
} }
int r_data_destroy(dp) int r_data_destroy(Data **dp) {
Data **dp; if(!dp || !*dp)
{ return (0);
if(!dp || !*dp)
return(0);
if((*dp)->data) if((*dp)->data)
free((*dp)->data); free((*dp)->data);
free(*dp); free(*dp);
*dp=0; *dp = 0;
return(0); return (0);
} }
int r_data_copy(dst,src) int r_data_copy(Data *dst, Data *src) {
Data *dst; if(!(dst->data = (UCHAR *)malloc(src->len)))
Data *src; ERETURN(R_NO_MEMORY);
{ memcpy(dst->data, src->data, dst->len = src->len);
if(!(dst->data=(UCHAR *)malloc(src->len))) return (0);
ERETURN(R_NO_MEMORY); }
memcpy(dst->data,src->data,dst->len=src->len);
return(0);
}
int r_data_zfree(d) int r_data_zfree(Data *d) {
Data *d; if(!d)
{ return (0);
if(!d) if(!d->data)
return(0); return (0);
if(!d->data) memset(d->data, 0, d->len);
return(0); free(d->data);
memset(d->data,0,d->len); return (0);
free(d->data); }
return(0);
}
int r_data_compare(d1,d2)
Data *d1;
Data *d2;
{
if(d1->len<d2->len)
return(-1);
if(d2->len<d1->len)
return(-1);
return(memcmp(d1->data,d2->data,d1->len));
}
int r_data_compare(Data *d1, Data *d2) {
if(d1->len < d2->len)
return (-1);
if(d2->len < d1->len)
return (-1);
return (memcmp(d1->data, d2->data, d1->len));
}

6
common/lib/r_data.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_data.h,v 1.2 2000/10/17 16:10:00 ekr Exp $ $Id: r_data.h,v 1.2 2000/10/17 16:10:00 ekr Exp $
@ -43,10 +44,7 @@
ekr@rtfm.com Fri Feb 4 08:58:48 2000 ekr@rtfm.com Fri Feb 4 08:58:48 2000
*/ */
#ifndef _r_data_h #ifndef _r_data_h
#define _r_data_h #define _r_data_h
#endif #endif

18
common/lib/r_errors.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_errors.c,v 1.3 2001/12/24 06:06:27 ekr Exp $ $Id: r_errors.c,v 1.3 2001/12/24 06:06:27 ekr Exp $
@ -43,18 +44,15 @@
ekr@rtfm.com Tue Feb 16 16:37:05 1999 ekr@rtfm.com Tue Feb 16 16:37:05 1999
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include "r_common.h" #include "r_common.h"
#include "r_errors.h" #include "r_errors.h"
int verr_exit(char *fmt,...) int verr_exit(char *fmt, ...) {
{ va_list ap;
va_list ap;
va_start(ap,fmt); va_start(ap, fmt);
vfprintf(stderr,fmt,ap); vfprintf(stderr, fmt, ap);
exit(1); exit(1);
} }

289
common/lib/r_list.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_list.c,v 1.4 2001/12/24 06:06:27 ekr Exp $ $Id: r_list.c,v 1.4 2001/12/24 06:06:27 ekr Exp $
@ -43,191 +44,171 @@
ekr@rtfm.com Tue Jan 19 08:36:39 1999 ekr@rtfm.com Tue Jan 19 08:36:39 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include "r_list.h" #include "r_list.h"
typedef struct r_list_el_ { typedef struct r_list_el_ {
void *data; void *data;
struct r_list_el_ *next; struct r_list_el_ *next;
struct r_list_el_ *prev; struct r_list_el_ *prev;
int (*copy) PROTO_LIST((void **new,void *old)); int(*copy) PROTO_LIST((void **new, void *old));
int (*destroy) PROTO_LIST((void **ptr)); int(*destroy) PROTO_LIST((void **ptr));
} r_list_el; } r_list_el;
struct r_list_ { struct r_list_ {
struct r_list_el_ *first; struct r_list_el_ *first;
struct r_list_el_ *last; struct r_list_el_ *last;
}; };
int r_list_create(listp) int r_list_create(r_list **listp) {
r_list **listp; r_list *list = 0;
{ int _status;
r_list *list=0;
int _status;
if(!(list=(r_list *)calloc(sizeof(r_list),1))) if(!(list = (r_list *)calloc(sizeof(r_list), 1)))
ABORT(R_NO_MEMORY);
list->first = 0;
list->last = 0;
*listp = list;
_status = 0;
abort:
return (_status);
}
int r_list_destroy(r_list **listp) {
r_list *list;
r_list_el *el;
if(!listp || !*listp)
return (0);
list = *listp;
el = list->first;
while(el) {
r_list_el *el_t;
if(el->destroy && el->data)
el->destroy(&el->data);
el_t = el;
el = el->next;
free(el_t);
}
free(list);
*listp = 0;
return (0);
}
int r_list_copy(r_list **outp, r_list *in) {
r_list *out = 0;
r_list_el *el, *el2, *last = 0;
int r, _status;
if(r = r_list_create(&out))
ABORT(r);
for(el = in->first; in; el = el->next) {
if(!(el2 = (r_list_el *)calloc(sizeof(r_list_el), 1)))
ABORT(R_NO_MEMORY); ABORT(R_NO_MEMORY);
list->first=0; if(el->copy && el->data) {
list->last=0; if(r = el->copy(&el2->data, el->data))
*listp=list; ABORT(r);
_status=0;
abort:
return(_status);
}
int r_list_destroy(listp)
r_list **listp;
{
r_list *list;
r_list_el *el;
if(!listp || !*listp)
return(0);
list=*listp;
el=list->first;
while(el){
r_list_el *el_t;
if(el->destroy && el->data)
el->destroy(&el->data);
el_t=el;
el=el->next;
free(el_t);
} }
free(list); el2->copy = el->copy;
*listp=0; el2->destroy = el->destroy;
return(0); if(!(out->first))
out->first = el2;
el2->prev = last;
last->next = el2;
last = el2;
} }
int r_list_copy(outp,in) out->last = last;
r_list**outp;
r_list *in;
{
r_list *out=0;
r_list_el *el,*el2,*last=0;
int r, _status;
if(r=r_list_create(&out)) *outp = out;
ABORT(r);
for(el=in->first;in;el=el->next){ _status = 0;
if(!(el2=(r_list_el *)calloc(sizeof(r_list_el),1))) abort:
ABORT(R_NO_MEMORY); if(_status)
r_list_destroy(&out);
return (_status);
}
if(el->copy && el->data){ int r_list_insert(list, value, copy, destroy) r_list *list;
if(r=el->copy(&el2->data,el->data)) void *value;
ABORT(r); int(*copy) PROTO_LIST((void **out, void *in));
} int(*destroy) PROTO_LIST((void **val));
{
r_list_el *el = 0;
int _status;
el2->copy=el->copy; if(!(el = (r_list_el *)calloc(sizeof(r_list_el), 1)))
el2->destroy=el->destroy; ABORT(R_NO_MEMORY);
el->data = value;
el->copy = copy;
el->destroy = destroy;
if(!(out->first)) el->prev = 0;
out->first=el2; el->next = list->first;
if(list->first) {
el2->prev=last; list->first->prev = el;
last->next=el2;
last=el2;
}
out->last=last;
*outp=out;
_status=0;
abort:
if(_status)
r_list_destroy(&out);
return(_status);
} }
list->first = el;
int r_list_insert(list,value,copy,destroy) _status = 0;
r_list *list; abort:
void *value; return (_status);
int (*copy) PROTO_LIST((void **out, void *in)); }
int (*destroy) PROTO_LIST((void **val));
{
r_list_el *el=0;
int _status;
if(!(el=(r_list_el *)calloc(sizeof(r_list_el),1))) int r_list_append(list, value, copy, destroy) r_list *list;
ABORT(R_NO_MEMORY); void *value;
el->data=value; int(*copy) PROTO_LIST((void **out, void *in));
el->copy=copy; int(*destroy) PROTO_LIST((void **val));
el->destroy=destroy; {
r_list_el *el = 0;
int _status;
el->prev=0; if(!(el = (r_list_el *)calloc(sizeof(r_list_el), 1)))
el->next=list->first; ABORT(R_NO_MEMORY);
if(list->first){ el->data = value;
list->first->prev=el; el->copy = copy;
} el->destroy = destroy;
list->first=el;
_status=0; el->prev = list->last;
abort: el->next = 0;
return(_status);
}
int r_list_append(list,value,copy,destroy) if(list->last)
r_list *list; list->last->next = el;
void *value; else
int (*copy) PROTO_LIST((void **out, void *in)); list->first = el;
int (*destroy) PROTO_LIST((void **val));
{
r_list_el *el=0;
int _status;
if(!(el=(r_list_el *)calloc(sizeof(r_list_el),1))) list->last = el;
ABORT(R_NO_MEMORY);
el->data=value;
el->copy=copy;
el->destroy=destroy;
el->prev=list->last; _status = 0;
el->next=0; abort:
return (_status);
if(list->last) list->last->next=el; }
else list->first=el;
list->last=el;
_status=0;
abort:
return(_status);
}
int r_list_init_iter(list,iter)
r_list *list;
r_list_iterator *iter;
{
iter->list=list;
iter->ptr=list->first;
return(0);
}
int r_list_iter(iter,val)
r_list_iterator *iter;
void **val;
{
if(!iter->ptr)
return(R_EOD);
*val=iter->ptr->data;
iter->ptr=iter->ptr->next;
return(0);
}
int r_list_init_iter(r_list *list, r_list_iterator *iter) {
iter->list = list;
iter->ptr = list->first;
return (0);
}
int r_list_iter(r_list_iterator *iter, void **val) {
if(!iter->ptr)
return (R_EOD);
*val = iter->ptr->data;
iter->ptr = iter->ptr->next;
return (0);
}

26
common/lib/r_replace.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_replace.c,v 1.2 2000/10/17 16:10:00 ekr Exp $ $Id: r_replace.c,v 1.2 2000/10/17 16:10:00 ekr Exp $
@ -43,24 +44,19 @@
ekr@rtfm.com Sun Oct 1 11:18:49 2000 ekr@rtfm.com Sun Oct 1 11:18:49 2000
*/ */
#include "r_common.h"
#include "r_common.h"
#ifndef HAVE_STRDUP #ifndef HAVE_STRDUP
char *strdup(str) char *strdup(char *str) {
char *str; int len = strlen(str);
{ char *n;
int len=strlen(str);
char *n;
if(!(n=(char *)malloc(len+1))) if(!(n = (char *)malloc(len + 1)))
return(0); return (0);
memcpy(n,str,len+1); memcpy(n, str, len + 1);
return(n); return (n);
} }
#endif #endif

156
common/lib/r_time.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: r_time.c,v 1.6 2002/09/09 21:02:58 ekr Exp $ $Id: r_time.c,v 1.6 2002/09/09 21:02:58 ekr Exp $
@ -43,8 +44,6 @@
ekr@rtfm.com Thu Mar 4 08:43:46 1999 ekr@rtfm.com Thu Mar 4 08:43:46 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include <r_time.h> #include <r_time.h>
@ -52,106 +51,97 @@
#include <windows.h> #include <windows.h>
int gettimeofday(struct timeval *tv, struct timezone *tzp) int gettimeofday(struct timeval *tv, struct timezone *tzp) {
{ /* JAN1_1970_OFFSET is the number of 100-nanoseconds ticks
/* JAN1_1970_OFFSET is the number of 100-nanoseconds ticks between midnight jan 1, 1970 and jan 1, 1601.
between midnight jan 1, 1970 and jan 1, 1601. */
*/
const ULARGE_INTEGER JAN1_1970_OFFSET = {0xd53e8000, 0x019db1de}; const ULARGE_INTEGER JAN1_1970_OFFSET = {0xd53e8000, 0x019db1de};
ULARGE_INTEGER currentTimeSinceJan_1_1970; ULARGE_INTEGER currentTimeSinceJan_1_1970;
FILETIME currentTime; FILETIME currentTime;
GetSystemTimeAsFileTime( &currentTime ); GetSystemTimeAsFileTime(&currentTime);
currentTimeSinceJan_1_1970.LowPart = currentTime.dwLowDateTime; currentTimeSinceJan_1_1970.LowPart = currentTime.dwLowDateTime;
currentTimeSinceJan_1_1970.HighPart = currentTime.dwHighDateTime; currentTimeSinceJan_1_1970.HighPart = currentTime.dwHighDateTime;
currentTimeSinceJan_1_1970.QuadPart -= JAN1_1970_OFFSET.QuadPart; currentTimeSinceJan_1_1970.QuadPart -= JAN1_1970_OFFSET.QuadPart;
/* At this point, currentTimeSinceJan_1_1970 contains the /* At this point, currentTimeSinceJan_1_1970 contains the
number of 100-nanosecond 'ticks' since midnight, Jan. 1, number of 100-nanosecond 'ticks' since midnight, Jan. 1,
1970. This is equivalent to 10 * the number of microseconds 1970. This is equivalent to 10 * the number of microseconds
elapsed since this time. The BSD man pages for gettimeofday() elapsed since this time. The BSD man pages for gettimeofday()
suggest that we should return the whole number of seconds in suggest that we should return the whole number of seconds in
the tv_sec field, and the fractional number of seconds in units the tv_sec field, and the fractional number of seconds in units
of microseconds in the tv_usec field. of microseconds in the tv_usec field.
sec = time / 10000000, usec = (time % 10000000) / 10; sec = time / 10000000, usec = (time % 10000000) / 10;
*/ */
tv->tv_sec = currentTimeSinceJan_1_1970.QuadPart / 10000000; tv->tv_sec = currentTimeSinceJan_1_1970.QuadPart / 10000000;
tv->tv_usec = (currentTimeSinceJan_1_1970.QuadPart % 10000000) / 10; tv->tv_usec = (currentTimeSinceJan_1_1970.QuadPart % 10000000) / 10;
return 0; return 0;
} }
#endif #endif
/*Note that t1 must be > t0 */ /*Note that t1 must be > t0 */
int r_timeval_diff(t1,t0,diff) int r_timeval_diff(struct timeval *t1,
struct timeval *t1; struct timeval *t0,
struct timeval *t0; struct timeval *diff) {
struct timeval *diff; long d;
{
long d;
if(t0->tv_sec > t1->tv_sec) if(t0->tv_sec > t1->tv_sec)
ERETURN(R_BAD_ARGS); ERETURN(R_BAD_ARGS);
/*Easy case*/ /*Easy case*/
if(t0->tv_usec <= t1->tv_usec){ if(t0->tv_usec <= t1->tv_usec) {
diff->tv_sec=t1->tv_sec - t0->tv_sec; diff->tv_sec = t1->tv_sec - t0->tv_sec;
diff->tv_usec=t1->tv_usec - t0->tv_usec; diff->tv_usec = t1->tv_usec - t0->tv_usec;
return(0); return (0);
}
/*Hard case*/
d=t0->tv_usec - t1->tv_usec;
if(t1->tv_sec < (t0->tv_sec + 1))
ERETURN(R_BAD_ARGS);
diff->tv_sec=t1->tv_sec - (t0->tv_sec + 1);
diff->tv_usec=1000000 - d;
return(0);
} }
int r_timeval_add(t1,t2,sum) /*Hard case*/
struct timeval *t1; d = t0->tv_usec - t1->tv_usec;
struct timeval *t2; if(t1->tv_sec < (t0->tv_sec + 1))
struct timeval *sum; ERETURN(R_BAD_ARGS);
{ diff->tv_sec = t1->tv_sec - (t0->tv_sec + 1);
long tv_sec,tv_usec,d; diff->tv_usec = 1000000 - d;
tv_sec=t1->tv_sec + t2->tv_sec; return (0);
}
d=t1->tv_usec + t2->tv_usec; int r_timeval_add(struct timeval *t1, struct timeval *t2, struct timeval *sum) {
if(d>1000000){ long tv_sec, tv_usec, d;
tv_sec++;
tv_usec=d-1000000;
}
else{
tv_usec=d;
}
sum->tv_sec=tv_sec; tv_sec = t1->tv_sec + t2->tv_sec;
sum->tv_usec=tv_usec;
return(0); d = t1->tv_usec + t2->tv_usec;
if(d > 1000000) {
tv_sec++;
tv_usec = d - 1000000;
} else {
tv_usec = d;
} }
UINT8 r_timeval2int(tv) sum->tv_sec = tv_sec;
struct timeval *tv; sum->tv_usec = tv_usec;
{
UINT8 r=0;
r=(tv->tv_sec); return (0);
r*=1000000; }
r+=tv->tv_usec;
return r; UINT8
} r_timeval2int(struct timeval *tv) {
UINT8 r = 0;
UINT8 r_gettimeint() r = (tv->tv_sec);
{ r *= 1000000;
struct timeval tv; r += tv->tv_usec;
gettimeofday(&tv,0); return r;
}
return r_timeval2int(&tv); UINT8
} r_gettimeint(void) {
struct timeval tv;
gettimeofday(&tv, 0);
return r_timeval2int(&tv);
}

217
common/lib/threads/pthreads/pthread.c
View file

@ -7,144 +7,125 @@
ekr@rtfm.com Tue Feb 23 15:08:03 1999 ekr@rtfm.com Tue Feb 23 15:08:03 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include <r_thread.h> #include <r_thread.h>
#include <pthread.h> #include <pthread.h>
static int thread_count=0; static int thread_count = 0;
typedef struct { typedef struct {
void (*func) PROTO_LIST((void *)); void(*func) PROTO_LIST((void *));
void *arg; void *arg;
} helper; } helper;
static void *r_thread_real_create PROTO_LIST((void *arg)); static void *r_thread_real_create PROTO_LIST((void *arg));
static void *r_thread_real_create(arg) static void *r_thread_real_create(void *arg) {
void *arg; helper *h;
{
helper *h;
h=(helper *)arg; h = (helper *)arg;
thread_count++; thread_count++;
h->func(h->arg); h->func(h->arg);
thread_count--; thread_count--;
free(h); free(h);
return(0); return (0);
} }
int r_thread_fork(func,arg,id) int r_thread_fork(func, arg, id) void(*func) PROTO_LIST((void *));
void (*func) PROTO_LIST((void *)); void *arg;
void *arg; r_thread *id;
r_thread *id; {
{ pthread_t thread;
pthread_t thread; helper *h;
helper *h; int r, _status;
int r,_status;
h=(helper *)malloc(sizeof(helper)); h = (helper *)malloc(sizeof(helper));
h->func=func; h->func = func;
h->arg=arg; h->arg = arg;
if(r=pthread_create(&thread,0,r_thread_real_create,(void *)h)) if(r = pthread_create(&thread, 0, r_thread_real_create, (void *)h))
ABORT(R_INTERNAL); ABORT(R_INTERNAL);
_status=0; _status = 0;
abort: abort:
return(_status); return (_status);
} }
int r_thread_yield() int r_thread_yield(void) {
{ pthread_yield();
}
int r_thread_exit(void) {
thread_count--;
pthread_exit(0);
return (0);
}
int r_thread_wait_last(void) {
do {
pthread_yield(); pthread_yield();
usleep(10000);
DBG((0, "%d threads left", thread_count));
} while(thread_count);
return (0);
}
int r_rwlock_create(r_rwlock **lockp) {
pthread_rwlock_t *lock;
int r;
if(!(lock = (pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t))))
ERETURN(R_NO_MEMORY);
if(r = pthread_rwlock_init(lock, 0))
ERETURN(R_INTERNAL);
*lockp = (void *)lock;
return (0);
}
int r_rwlock_destroy(r_rwlock **lock) {
pthread_rwlock_t *plock;
if(!lock || !*lock)
return (0);
plock = (pthread_rwlock_t *)(*lock);
pthread_rwlock_destroy(plock);
return (0);
}
int r_rwlock_lock(r_rwlock *lock, int action) {
pthread_rwlock_t *plock;
int r, _status;
plock = (pthread_rwlock_t *)lock;
switch(action) {
case R_RWLOCK_UNLOCK:
if(r = pthread_rwlock_unlock(plock))
ABORT(R_INTERNAL);
break;
case R_RWLOCK_RLOCK:
if(r = pthread_rwlock_rdlock(plock))
ABORT(R_INTERNAL);
break;
case R_RWLOCK_WLOCK:
if(r = pthread_rwlock_wrlock(plock))
ABORT(R_INTERNAL);
break;
default:
ABORT(R_BAD_ARGS);
} }
int r_thread_exit() _status = 0;
{ abort:
thread_count--; return (_status);
pthread_exit(0); }
return(0);
}
int r_thread_wait_last()
{
do {
pthread_yield();
usleep(10000);
DBG((0,"%d threads left",thread_count));
} while (thread_count);
return(0);
}
int r_rwlock_create(lockp)
r_rwlock **lockp;
{
pthread_rwlock_t *lock;
int r;
if(!(lock=(pthread_rwlock_t *)malloc(sizeof(pthread_rwlock_t))))
ERETURN(R_NO_MEMORY);
if(r=pthread_rwlock_init(lock,0))
ERETURN(R_INTERNAL);
*lockp=(void *)lock;
return(0);
}
int r_rwlock_destroy(lock)
r_rwlock **lock;
{
pthread_rwlock_t *plock;
if(!lock || !*lock)
return(0);
plock=(pthread_rwlock_t *)(*lock);
pthread_rwlock_destroy(plock);
return(0);
}
int r_rwlock_lock(lock,action)
r_rwlock *lock;
int action;
{
pthread_rwlock_t *plock;
int r,_status;
plock=(pthread_rwlock_t *)lock;
switch(action){
case R_RWLOCK_UNLOCK:
if(r=pthread_rwlock_unlock(plock))
ABORT(R_INTERNAL);
break;
case R_RWLOCK_RLOCK:
if(r=pthread_rwlock_rdlock(plock))
ABORT(R_INTERNAL);
break;
case R_RWLOCK_WLOCK:
if(r=pthread_rwlock_wrlock(plock))
ABORT(R_INTERNAL);
break;
default:
ABORT(R_BAD_ARGS);
}
_status=0;
abort:
return(_status);
}

30
docker/README.md Normal file
View file

@ -0,0 +1,30 @@
# Docker instructions
*Note: Dockerfiles are only provided for Debian-like distributions so far.*
## Configure image building:
Uncomment the distribution reference you want to use, in top section in
`debian-distros/Dockerfile`.
## Build the image:
`cd debian-distros`
`./docker_build.sh`
## Run the container, and start ssldump inside the container:
`./docker_run.sh`
`(in container) sudo ssldump -n -i eth0 -j -AH`
## Mirror traffic to container
Outside of the container, adjust local interface name and container IP address
in `mirror_traffic_to_container.sh`.
Then mirror local traffic to ssldump container:
`./mirror_traffic_to_container.sh`

28
docker/debian-bullseye/Dockerfile
View file

@ -1,28 +0,0 @@
FROM debian:bullseye-slim
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CC=/usr/bin/clang CFLAGS="-D_FORTIFY_SOURCE=2 -fstack-protector-strong -Wformat -Werror=format-security -g" && \
make && \
sudo make install
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/debian-bullseye/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-bullseye
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/debian-bullseye/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-bullseye
docker run -it ssldump-${distribution}:${ssldump_version}

6
docker/debian-buster/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-buster
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/debian-buster/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-buster
docker run -it ssldump-${distribution}:${ssldump_version}

20
docker/debian-buster/Dockerfile → docker/debian-distros/Dockerfile
View file

@ -1,11 +1,16 @@
FROM debian:buster-slim #FROM debian:bookworm-slim
#FROM debian:bullseye-slim
#FROM debian:buster-slim
FROM ubuntu:jammy
#FROM ubuntu:focal
ENV LANG C ENV LANG C
ENV DEBIAN_FRONTEND noninteractive ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \ RUN apt-get update && \
apt-get dist-upgrade -y && \ apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \ apt-get install -y --no-install-recommends ca-certificates sudo git build-essential cmake ninja-build clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean apt-get clean
RUN useradd -ms /bin/bash ssldump RUN useradd -ms /bin/bash ssldump
@ -15,13 +20,12 @@ RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump USER ssldump
RUN cd /home/ssldump && \ RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build git clone https://github.com/adulau/ssldump.git ssldump-build
RUN cd /home/ssldump/build && \ RUN cd /home/ssldump/ssldump-build && \
./autogen.sh && \ cmake -G Ninja -B build && \
./configure CC=/usr/bin/clang && \ ninja -C build && \
make && \ sudo ninja -C build install
sudo make install
WORKDIR "/home/ssldump" WORKDIR "/home/ssldump"

6
docker/debian-distros/docker_build.sh Executable file
View file

@ -0,0 +1,6 @@
#!/bin/bash
ssldump_version=$(awk '/\s+VERSION/ {print $2}' ../../CMakeLists.txt)
distribution=$(awk '/^FROM/ {gsub(":","-"); print $2}' Dockerfile)
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/debian-distros/docker_run.sh Executable file
View file

@ -0,0 +1,7 @@
#!/bin/bash
ssldump_version=$(awk '/\s+VERSION/ {print $2}' ../../CMakeLists.txt)
distribution=$(awk '/^FROM/ {gsub(":","-"); print $2}' Dockerfile)
docker run -it ssldump-${distribution}:${ssldump_version}

28
docker/debian-stretch/Dockerfile
View file

@ -1,28 +0,0 @@
FROM debian:stretch-slim
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CC=/usr/bin/clang && \
make && \
sudo make install
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/debian-stretch/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-stretch
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/debian-stretch/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=debian-stretch
docker run -it ssldump-${distribution}:${ssldump_version}

2
docker/mirror_traffic_to_container.sh
View file

@ -1,6 +1,6 @@
#!/bin/bash #!/bin/bash
local_if=ens3f0 local_if=eth0
container_ip=172.17.0.2 container_ip=172.17.0.2
sudo iptables -t mangle -I PREROUTING 1 -i ${local_if} -j TEE --gateway ${container_ip} sudo iptables -t mangle -I PREROUTING 1 -i ${local_if} -j TEE --gateway ${container_ip}

28
docker/ubuntu-bionic/Dockerfile
View file

@ -1,28 +0,0 @@
FROM ubuntu:bionic
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CC=/usr/bin/clang && \
make && \
sudo make install
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/ubuntu-bionic/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-bionic
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/ubuntu-bionic/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-bionic
docker run -it ssldump-${distribution}:${ssldump_version}

28
docker/ubuntu-focal/Dockerfile
View file

@ -1,28 +0,0 @@
FROM ubuntu:focal
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CC=/usr/bin/clang && \
make && \
sudo make install
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/ubuntu-focal/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-focal
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/ubuntu-focal/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-focal
docker run -it ssldump-${distribution}:${ssldump_version}

28
docker/ubuntu-groovy/Dockerfile
View file

@ -1,28 +0,0 @@
FROM ubuntu:groovy
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang libssl-dev libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CC=/usr/bin/clang && \
make && \
sudo make install
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/ubuntu-groovy/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-groovy
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/ubuntu-groovy/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-groovy
docker run -it ssldump-${distribution}:${ssldump_version}

41
docker/ubuntu-xenial/Dockerfile
View file

@ -1,41 +0,0 @@
FROM ubuntu:xenial
ENV LANG C
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update && \
apt-get dist-upgrade -y && \
apt-get install -y --no-install-recommends ca-certificates sudo git build-essential automake autoconf clang wget libpcap-dev libnet1-dev libjson-c-dev iproute2 && \
apt-get clean
RUN useradd -ms /bin/bash ssldump
RUN passwd -d ssldump
RUN printf 'Defaults:ssldump env_keep=LD_LIBRARY_PATH\n' | tee -a /etc/sudoers
RUN printf 'ssldump ALL=(ALL) ALL\n' | tee -a /etc/sudoers
USER ssldump
RUN mkdir /home/ssldump/openssl && \
cd /home/ssldump/openssl && \
wget https://www.openssl.org/source/openssl-1.1.1j.tar.gz && \
tar xvfz openssl-1.1.1j.tar.gz && \
cd openssl-1.1.1j && \
./config && \
make -j 2
RUN cd /home/ssldump && \
git clone https://github.com/adulau/ssldump.git build
RUN cd /home/ssldump/build && \
./autogen.sh && \
./configure CFLAGS="-I../openssl/openssl-1.1.1j/include" LDFLAGS="-L../openssl/openssl-1.1.1j -lcrypto -lssl" && \
make && \
sudo make install
ENV LD_LIBRARY_PATH /home/ssldump/openssl/openssl-1.1.1j
RUN printf '#!/bin/bash\nexport LD_LIBRARY_PATH=/home/ssldump/openssl/openssl-1.1.1j\nssldump $@\n' > /home/ssldump/run_ssldump.sh
RUN chmod +x /home/ssldump/run_ssldump.sh
WORKDIR "/home/ssldump"
CMD ["/bin/bash"]

6
docker/ubuntu-xenial/docker_build.sh
View file

@ -1,6 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-xenial
docker build -t "ssldump-${distribution}:${ssldump_version}" .

7
docker/ubuntu-xenial/docker_run.sh
View file

@ -1,7 +0,0 @@
#!/bin/bash
ssldump_version=1.4b
distribution=ubuntu-xenial
docker run -it ssldump-${distribution}:${ssldump_version}

151
null/null_analyze.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: null_analyze.c,v 1.6 2001/11/26 22:28:16 ekr Exp $ $Id: null_analyze.c,v 1.6 2001/11/26 22:28:16 ekr Exp $
@ -43,113 +44,105 @@
ekr@rtfm.com Thu Jan 7 22:58:27 1999 ekr@rtfm.com Thu Jan 7 22:58:27 1999
*/ */
#include <ctype.h> #include <ctype.h>
#include "network.h" #include "network.h"
#include "proto_mod.h" #include "proto_mod.h"
#include "debug.h" #include "debug.h"
typedef struct null_analyzer_ { typedef struct null_analyzer_ {
int num; int num;
} null_analyzer; } null_analyzer;
static int create_null_analyzer PROTO_LIST((void *handle, static int create_null_analyzer PROTO_LIST((void *handle,
proto_ctx *ctx,tcp_conn *conn,proto_obj **objp, proto_ctx *ctx,
struct sockaddr_storage *i_addr,u_short i_port, tcp_conn *conn,
struct sockaddr_storage *r_addr,u_short r_port, struct timeval *base_time)); proto_obj **objp,
struct sockaddr_storage *i_addr,
u_short i_port,
struct sockaddr_storage *r_addr,
u_short r_port,
struct timeval *base_time));
static int create_null_analyzer(void *handle, proto_ctx *ctx, tcp_conn *conn, static int create_null_analyzer(void *handle,
proto_obj **objp, struct sockaddr_storage *i_addr, u_short i_port, struct sockaddr_storage *r_addr, proto_ctx *ctx,
u_short r_port, struct timeval *base_time) tcp_conn *conn,
{ proto_obj **objp,
null_analyzer *obj=0; struct sockaddr_storage *i_addr,
static int ctr; u_short i_port,
struct sockaddr_storage *r_addr,
u_short r_port,
struct timeval *base_time) {
null_analyzer *obj = 0;
static int ctr;
if(!(obj=(null_analyzer *)calloc(1,sizeof(null_analyzer)))) if(!(obj = (null_analyzer *)calloc(1, sizeof(null_analyzer))))
ERETURN(R_NO_MEMORY); ERETURN(R_NO_MEMORY);
obj->num=ctr++; obj->num = ctr++;
DBG((0,"Creating analyzer for connection %d\n",obj->num)); DBG((0, "Creating analyzer for connection %d\n", obj->num));
*objp=(proto_obj *)obj; *objp = (proto_obj *)obj;
return(0); return (0);
} }
int destroy_null_analyzer(objp) int destroy_null_analyzer(proto_obj **objp) {
proto_obj **objp; null_analyzer *obj;
{
null_analyzer *obj;
if(!objp || !*objp) if(!objp || !*objp)
return(0); return (0);
obj=(null_analyzer *)*objp; obj = (null_analyzer *)*objp;
DBG((0,"Destroying analyzer for connection %d\n",obj->num)); DBG((0, "Destroying analyzer for connection %d\n", obj->num));
free(*objp); free(*objp);
*objp=0; *objp = 0;
return(0); return (0);
} }
int data_null_analyzer(_obj,seg,direction) int data_null_analyzer(proto_obj *_obj, segment *seg, int direction) {
proto_obj *_obj;
segment *seg;
int direction;
{
#ifdef DEBUG #ifdef DEBUG
null_analyzer *obj=(null_analyzer *)_obj; null_analyzer *obj = (null_analyzer *)_obj;
#endif #endif
DBG((0,"Processing data for connection %d dir %d\n",obj->num, DBG((0, "Processing data for connection %d dir %d\n", obj->num, direction));
direction));
for(;seg;seg=seg->next){ for(; seg; seg = seg->next) {
int i; int i;
for(i=0;i<MIN(seg->len,20);i++){ for(i = 0; i < MIN(seg->len, 20); i++) {
if(!isascii(seg->data[i])) if(!isascii(seg->data[i]))
break; break;
}
if(i<20)
xdump("NSEGMENT",seg->data,seg->len);
else{
printf("NSEGMENT: ");
fwrite(seg->data,1,seg->len,stdout);
}
printf("====\n");
} }
if(i < 20)
return(0); xdump("NSEGMENT", seg->data, seg->len);
else {
printf("NSEGMENT: ");
fwrite(seg->data, 1, seg->len, stdout);
}
printf("====\n");
} }
int fin_null_analyzer(_obj,p,direction) return (0);
proto_obj *_obj; }
packet *p;
int direction; int fin_null_analyzer(proto_obj *_obj, packet *p, int direction) {
{
#ifdef DEBUG #ifdef DEBUG
null_analyzer *obj=(null_analyzer *)_obj; null_analyzer *obj = (null_analyzer *)_obj;
#endif #endif
DBG((0,"Received FIN on connection %d\n",obj->num)); DBG((0, "Received FIN on connection %d\n", obj->num));
return(0); return (0);
} }
static struct proto_mod_vtbl_ null_vtbl = {
0,
0,
static struct proto_mod_vtbl_ null_vtbl ={ 0,
0, create_null_analyzer,
0, 0,
0, destroy_null_analyzer,
create_null_analyzer, data_null_analyzer,
destroy_null_analyzer, fin_null_analyzer,
data_null_analyzer,
fin_null_analyzer,
}; };
struct proto_mod_ null_mod = { struct proto_mod_ null_mod = {0, &null_vtbl};
0,
&null_vtbl
};

5
null/null_analyze.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: null_analyze.h,v 1.2 2000/10/17 16:10:01 ekr Exp $ $Id: null_analyze.h,v 1.2 2000/10/17 16:10:01 ekr Exp $
@ -43,11 +44,9 @@
ekr@rtfm.com Fri Jan 8 11:23:10 1999 ekr@rtfm.com Fri Jan 8 11:23:10 1999
*/ */
#ifndef _null_analyze_h #ifndef _null_analyze_h
#define _null_analyze_h #define _null_analyze_h
extern proto_mod null_mod; extern proto_mod null_mod;
#endif #endif

24
pcap/attrib.h
View file

@ -46,14 +46,14 @@
#define __attribute__(x) #define __attribute__(x)
#endif #endif
#define UNUSED __attribute__((unused)) #define UNUSED __attribute__((unused))
#define NORET __attribute__((noreturn)) #define NORET __attribute__((noreturn))
#define PRINTF(f,a) __attribute__((format(printf,(f),(a)))) #define PRINTF(f, a) __attribute__((format(printf, (f), (a))))
#define SCANF(f,a) __attribute__((format(scanf,(f),(a)))) #define SCANF(f, a) __attribute__((format(scanf, (f), (a))))
#define WUNRES __attribute__((warn_unused_result)) #define WUNRES __attribute__((warn_unused_result))
#define MALLOC __attribute__((malloc)) WUNRES #define MALLOC __attribute__((malloc)) WUNRES
#define NONNULL(...) __attribute__((nonnull(__VA_ARGS__))) #define NONNULL(...) __attribute__((nonnull(__VA_ARGS__)))
#define PURE __attribute__((pure)) #define PURE __attribute__((pure))
/* /*
* Branch prediction macros. * Branch prediction macros.
@ -61,11 +61,11 @@
*/ */
#if !defined(__GNUC__) && !defined(__clang__) #if !defined(__GNUC__) && !defined(__clang__)
#define likely(expr) (expr) #define likely(expr) (expr)
#define unlikely(expr) (expr) #define unlikely(expr) (expr)
#else #else
#define likely(expr) __builtin_expect((expr), 1) #define likely(expr) __builtin_expect((expr), 1)
#define unlikely(expr) __builtin_expect((expr), 0) #define unlikely(expr) __builtin_expect((expr), 0)
#endif #endif
#endif /* !ATTRIB_H */ #endif /* !ATTRIB_H */

1122
pcap/logpkt.c
View file

File diff suppressed because it is too large Load diff

46
pcap/logpkt.h
View file

@ -35,7 +35,6 @@
#include <stdint.h> #include <stdint.h>
#include <time.h> #include <time.h>
#ifndef WITHOUT_MIRROR #ifndef WITHOUT_MIRROR
#include <libnet.h> #include <libnet.h>
#else /* WITHOUT_MIRROR */ #else /* WITHOUT_MIRROR */
@ -44,28 +43,39 @@
#endif /* WITHOUT_MIRROR */ #endif /* WITHOUT_MIRROR */
typedef struct { typedef struct {
libnet_t *libnet; libnet_t *libnet;
uint8_t src_ether[ETHER_ADDR_LEN]; uint8_t src_ether[ETHER_ADDR_LEN];
uint8_t dst_ether[ETHER_ADDR_LEN]; uint8_t dst_ether[ETHER_ADDR_LEN];
struct sockaddr_storage src_addr; struct sockaddr_storage src_addr;
struct sockaddr_storage dst_addr; struct sockaddr_storage dst_addr;
uint32_t src_seq; uint32_t src_seq;
uint32_t dst_seq; uint32_t dst_seq;
size_t mss; size_t mss;
} logpkt_ctx_t; } logpkt_ctx_t;
#define LOGPKT_REQUEST 0 #define LOGPKT_REQUEST 0
#define LOGPKT_RESPONSE 1 #define LOGPKT_RESPONSE 1
int logpkt_pcap_open_fd(int fd) WUNRES; int logpkt_pcap_open_fd(int fd) WUNRES;
void logpkt_ctx_init(logpkt_ctx_t *, libnet_t *, size_t, void logpkt_ctx_init(logpkt_ctx_t *,
const uint8_t *, const uint8_t *, libnet_t *,
const struct sockaddr *, socklen_t, size_t,
const struct sockaddr *, socklen_t); const uint8_t *,
int logpkt_write_payload(logpkt_ctx_t *, int, int, const uint8_t *,
const unsigned char *, size_t) WUNRES; const struct sockaddr *,
socklen_t,
const struct sockaddr *,
socklen_t);
int logpkt_write_payload(logpkt_ctx_t *,
int,
int,
const unsigned char *,
size_t) WUNRES;
int logpkt_write_close(logpkt_ctx_t *, int, int); int logpkt_write_close(logpkt_ctx_t *, int, int);
int logpkt_ether_lookup(libnet_t *, uint8_t *, uint8_t *, int logpkt_ether_lookup(libnet_t *,
const char *, const char *) WUNRES; uint8_t *,
uint8_t *,
const char *,
const char *) WUNRES;
#endif /* !LOGPKT_H */ #endif /* !LOGPKT_H */

210
pcap/pcap_logger.c
View file

@ -17,137 +17,137 @@
#define DFLT_FILEMODE 0666 #define DFLT_FILEMODE 0666
static int init_pcap_logger PROTO_LIST((void * data)); static int init_pcap_logger PROTO_LIST((void *data));
static int deinit_pcap_logger PROTO_LIST(()); static int deinit_pcap_logger PROTO_LIST(());
static int create_pcap_logger PROTO_LIST((proto_obj **objp, struct sockaddr_storage *i_addr, static int create_pcap_logger PROTO_LIST((proto_obj * *objp,
u_short i_port,struct sockaddr_storage *r_addr, u_short r_port, struct timeval *base_time)); struct sockaddr_storage *i_addr,
static int destroy_pcap_logger PROTO_LIST((proto_obj **objp)); u_short i_port,
static int data_pcap_logger PROTO_LIST((proto_obj *_obj, unsigned char *data,unsigned int len, int dir)); struct sockaddr_storage *r_addr,
static int close_pcap_logger PROTO_LIST((proto_obj *_obj, unsigned char *data,unsigned int len, int dir)); u_short r_port,
struct timeval *base_time));
static int destroy_pcap_logger PROTO_LIST((proto_obj * *objp));
static int data_pcap_logger PROTO_LIST(
(proto_obj * _obj, unsigned char *data, unsigned int len, int dir));
static int close_pcap_logger PROTO_LIST(
(proto_obj * _obj, unsigned char *data, unsigned int len, int dir));
int pcap_fd = -1; int pcap_fd = -1;
static uint8_t content_pcap_src_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00, 0x11, 0x11, 0x11}; static uint8_t content_pcap_src_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00,
static uint8_t content_pcap_dst_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00, 0x22, 0x22, 0x22}; 0x11, 0x11, 0x11};
static uint8_t content_pcap_dst_ether[ETHER_ADDR_LEN] = {0x02, 0x00, 0x00,
0x22, 0x22, 0x22};
static int init_pcap_logger(data) static int init_pcap_logger(void *data) {
void *data; char *pcap_outfile = (char *)data;
{ pcap_fd = open(pcap_outfile, O_RDWR | O_CREAT, DFLT_FILEMODE);
char *pcap_outfile = (char *) data; if(pcap_fd == -1) {
pcap_fd = open(pcap_outfile, O_RDWR|O_CREAT, DFLT_FILEMODE); // printf("Failed to open pcap '%s' for writing\n", pcap_outfile);
if (pcap_fd == -1) { return -1;
//printf("Failed to open pcap '%s' for writing\n", pcap_outfile);
return -1;
}
if (logpkt_pcap_open_fd(pcap_fd) == -1) {
//printf("Failed to prepare '%s' for PCAP writing\n", pcap_outfile);
close(pcap_fd);
pcap_fd = -1;
return -1;
}
return 0;
} }
if(logpkt_pcap_open_fd(pcap_fd) == -1) {
static int deinit_pcap_logger() // printf("Failed to prepare '%s' for PCAP writing\n", pcap_outfile);
{
fdatasync(pcap_fd);
close(pcap_fd); close(pcap_fd);
return 0; pcap_fd = -1;
return -1;
} }
return 0;
}
static int create_pcap_logger(proto_obj **objp, struct sockaddr_storage *i_addr, u_short i_port, struct sockaddr_storage *r_addr, u_short r_port, struct timeval *base_time) static int deinit_pcap_logger(void) {
{ fdatasync(pcap_fd);
int r,_status; close(pcap_fd);
logpkt_ctx_t *pcap_obj=0; return 0;
struct sockaddr_in src_addr, dst_addr; }
if(!(pcap_obj=(logpkt_ctx_t *)calloc(1,sizeof(logpkt_ctx_t)))) static int create_pcap_logger(proto_obj **objp,
ABORT(R_NO_MEMORY); struct sockaddr_storage *i_addr,
u_short i_port,
struct sockaddr_storage *r_addr,
u_short r_port,
struct timeval *base_time) {
int r, _status;
logpkt_ctx_t *pcap_obj = 0;
struct sockaddr_in src_addr, dst_addr;
//src_addr.sin_family = AF_INET; if(!(pcap_obj = (logpkt_ctx_t *)calloc(1, sizeof(logpkt_ctx_t))))
//src_addr.sin_addr = *i_addr; ABORT(R_NO_MEMORY);
memcpy(&src_addr, i_addr, sizeof(struct sockaddr_in));
src_addr.sin_port = htons(i_port);
//dst_addr.sin_family = AF_INET; // src_addr.sin_family = AF_INET;
//dst_addr.sin_addr = *r_addr; // src_addr.sin_addr = *i_addr;
memcpy(&dst_addr, r_addr, sizeof(struct sockaddr_in)); memcpy(&src_addr, i_addr, sizeof(struct sockaddr_in));
dst_addr.sin_port = htons(r_port); src_addr.sin_port = htons(i_port);
logpkt_ctx_init(pcap_obj,NULL,0,content_pcap_src_ether, content_pcap_dst_ether, // dst_addr.sin_family = AF_INET;
(const struct sockaddr*)&src_addr, sizeof(src_addr), // dst_addr.sin_addr = *r_addr;
(const struct sockaddr*)&dst_addr, sizeof(dst_addr)); memcpy(&dst_addr, r_addr, sizeof(struct sockaddr_in));
*objp=(proto_obj *)pcap_obj; dst_addr.sin_port = htons(r_port);
_status=0;
abort: logpkt_ctx_init(pcap_obj, NULL, 0, content_pcap_src_ether,
if(_status){ content_pcap_dst_ether, (const struct sockaddr *)&src_addr,
destroy_pcap_logger((proto_obj **)&pcap_obj); sizeof(src_addr), (const struct sockaddr *)&dst_addr,
} sizeof(dst_addr));
return(_status); *objp = (proto_obj *)pcap_obj;
_status = 0;
abort:
if(_status) {
destroy_pcap_logger((proto_obj **)&pcap_obj);
} }
return (_status);
}
static int destroy_pcap_logger(objp) static int destroy_pcap_logger(proto_obj **objp) {
proto_obj **objp; logpkt_ctx_t *pcap_obj;
{
logpkt_ctx_t *pcap_obj;
if(!objp || !*objp) if(!objp || !*objp)
return(0); return (0);
pcap_obj=(logpkt_ctx_t *)*objp; pcap_obj = (logpkt_ctx_t *)*objp;
free(pcap_obj); free(pcap_obj);
*objp=0; *objp = 0;
return(0); return (0);
} }
static int data_pcap_logger(_obj,data,len,dir) static int data_pcap_logger(proto_obj *_obj,
proto_obj *_obj; unsigned char *data,
unsigned char *data; unsigned int len,
unsigned int len; int dir) {
int dir; logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj;
{ int direction;
logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj; int status;
int direction;
int status;
if (dir == DIR_I2R ) direction = LOGPKT_REQUEST; if(dir == DIR_I2R)
else direction = LOGPKT_RESPONSE; direction = LOGPKT_REQUEST;
else
direction = LOGPKT_RESPONSE;
status = logpkt_write_payload(pcap_obj,pcap_fd,direction,data,len); status = logpkt_write_payload(pcap_obj, pcap_fd, direction, data, len);
return status; return status;
} }
int close_pcap_logger(_obj,data,len,dir) int close_pcap_logger(proto_obj *_obj,
proto_obj *_obj; unsigned char *data,
unsigned char *data; unsigned int len,
unsigned int len; int dir) {
int dir; logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj;
{ int direction;
logpkt_ctx_t *pcap_obj = (logpkt_ctx_t *)_obj; int status;
int direction;
int status;
if (dir == DIR_I2R ) direction = LOGPKT_REQUEST; if(dir == DIR_I2R)
else direction = LOGPKT_RESPONSE; direction = LOGPKT_REQUEST;
else
direction = LOGPKT_RESPONSE;
status = logpkt_write_close(pcap_obj, pcap_fd, direction); status = logpkt_write_close(pcap_obj, pcap_fd, direction);
return status; return status;
} }
static struct logger_mod_vtbl_ pcap_vtbl ={ static struct logger_mod_vtbl_ pcap_vtbl = {
init_pcap_logger, init_pcap_logger, deinit_pcap_logger, create_pcap_logger,
deinit_pcap_logger, destroy_pcap_logger, data_pcap_logger, close_pcap_logger,
create_pcap_logger,
destroy_pcap_logger,
data_pcap_logger,
close_pcap_logger,
};
struct logger_mod_ pcap_mod = {
"PCAP",
&pcap_vtbl
}; };
struct logger_mod_ pcap_mod = {"PCAP", &pcap_vtbl};

1
pcap/pcap_logger.h
View file

@ -4,4 +4,3 @@
extern logger_mod pcap_mod; extern logger_mod pcap_mod;
#endif #endif

58
pcap/sys.c
View file

@ -53,47 +53,41 @@
/* /*
* Determine address family of addr * Determine address family of addr
*/ */
int int sys_get_af(const char *addr) {
sys_get_af(const char *addr) if(strstr(addr, ":"))
{ return AF_INET6;
if (strstr(addr, ":")) else if(!strpbrk(addr,
return AF_INET6; "abcdefghijklmnopqrstu"
else if (!strpbrk(addr, "abcdefghijklmnopqrstu" "vwxyzABCDEFGHIJKLMNOP"
"vwxyzABCDEFGHIJKLMNOP" "QRSTUVWXYZ-"))
"QRSTUVWXYZ-")) return AF_INET;
return AF_INET; else
else return AF_UNSPEC;
return AF_UNSPEC;
} }
static int sys_rand_seeded = 0; static int sys_rand_seeded = 0;
static void static void sys_rand_seed(void) {
sys_rand_seed(void) { struct timeval seed;
struct timeval seed;
if (gettimeofday(&seed, NULL) == -1) { if(gettimeofday(&seed, NULL) == -1) {
srandom((unsigned)time(NULL)); srandom((unsigned)time(NULL));
} else { } else {
srandom((unsigned)(seed.tv_sec ^ seed.tv_usec)); srandom((unsigned)(seed.tv_sec ^ seed.tv_usec));
} }
sys_rand_seeded = 1; sys_rand_seeded = 1;
} }
uint16_t uint16_t sys_rand16(void) {
sys_rand16(void) { if(unlikely(!sys_rand_seeded))
if (unlikely(!sys_rand_seeded)) sys_rand_seed();
sys_rand_seed(); return random();
return random();
} }
uint32_t uint32_t sys_rand32(void) {
sys_rand32(void) { if(unlikely(!sys_rand_seeded))
if (unlikely(!sys_rand_seeded)) sys_rand_seed();
sys_rand_seed(); return random();
return random();
} }
/* vim: set noet ft=c: */ /* vim: set noet ft=c: */

52
ssl/Attic/ciphersuites.h
View file

@ -1,52 +0,0 @@
/**
ciphersuites.h
Copyright (C) 1999-2000 RTFM, Inc.
All Rights Reserved
This package is a SSLv3/TLS protocol analyzer written by Eric Rescorla
<ekr@rtfm.com> and licensed by RTFM, Inc.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this software
must display the following acknowledgement:
This product includes software developed by Eric Rescorla for
RTFM, Inc.
4. Neither the name of RTFM, Inc. nor the name of Eric Rescorla may be
used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY ERIC RESCORLA AND RTFM, INC. ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE.
$Id: ciphersuites.h,v 1.2 2000/10/17 16:10:01 ekr Exp $
ekr@rtfm.com Sat Sep 23 18:01:27 2000
*/
#ifndef _ciphersuites_h
#define _ciphersuites_h
int ssl_find_cipher PROTO_LIST((int num,SSL_CipherSuite **cs));
#endif

1777
ssl/Attic/lex.yy.c
View file

File diff suppressed because it is too large Load diff

98
ssl/Attic/main.c
View file

@ -1,98 +0,0 @@
/**
main.c
Copyright (C) 1999-2000 RTFM, Inc.
All Rights Reserved
This package is a SSLv3/TLS protocol analyzer written by Eric Rescorla
<ekr@rtfm.com> and licensed by RTFM, Inc.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this software
must display the following acknowledgement:
This product includes software developed by Eric Rescorla for
RTFM, Inc.
4. Neither the name of RTFM, Inc. nor the name of Eric Rescorla may be
used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY ERIC RESCORLA AND RTFM, INC. ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE.
$Id: main.c,v 1.2 2000/10/17 16:10:01 ekr Exp $
ekr@rtfm.com Mon Jan 18 16:28:43 1999
*/
#include <stdarg.h>
#include <r_common.h>
extern int yydebug;
FILE *doth,*dotc;
int verr_exit(char *fmt,...)
{
va_list ap;
va_start(ap,fmt);
vfprintf(stderr,fmt,ap);
exit(1);
}
int main(argc,argv)
int argc;
char **argv;
{
char name[100];
FILE *in;
if(!(in=freopen(argv[1],"r",stdin)))
verr_exit("Couldn't open input file %s\n",argv[1]);
sprintf(name,"%s.c",argv[1]);
dotc=fopen(name,"w");
sprintf(name,"%s.h",argv[1]);
doth=fopen(name,"w");
fprintf(dotc,"#include \"network.h\"\n#include \"ssl_h.h\"\n#include \"sslprint.h\"\n#include \"sslxprint.h\"\n#ifdef OPENSSL\n#include <openssl/ssl.h>\n#endif\n");
fprintf(dotc,"#include \"%s\"\n",name);
yyparse();
}
extern int yylineno;
int yywrap()
{
;}
int yyerror(s)
char *s;
{
printf("Parse error %s at line %d\n",s,yylineno);
exit(1);
}

749
ssl/Attic/ssl.enums
View file

@ -1,749 +0,0 @@
select {
ChangeCipherSpec(20)
{@
ssl_process_change_cipher_spec(ssl,ssl->decoder,dir);
if(dir==DIR_I2R){
ssl->i_state=SSL_ST_SENT_CHANGE_CIPHER_SPEC;
}
else{
ssl->r_state=SSL_ST_SENT_CHANGE_CIPHER_SPEC;
}
printf("\n");
return(0);
@}
, Alert(21)
{@
int r;
if(ssl->record_encryption==REC_CIPHERTEXT){
printf("\n");
return(0);
}
if(data->len!=2){
fprintf(stderr,"Wrong length for alert message: %d\n",
data->len);
ERETURN(R_EOD);
}
P_(P_HL){
printf("\n");
SSL_DECODE_ENUM(ssl,"level",1,AlertLevel_decoder,P_HL,data,0);
printf("\n");
SSL_DECODE_ENUM(ssl,"value",1,AlertDescription_decoder,P_HL,data,0);
printf("\n");
}
else {
SSL_DECODE_ENUM(ssl,0,1,AlertLevel_decoder,SSL_PRINT_ALL,data,0);
SSL_DECODE_ENUM(ssl,0,1,AlertDescription_decoder,SSL_PRINT_ALL,data,0);
printf("\n");
}
return(0);
@},
Handshake(22)
{@
extern decoder HandshakeType_decoder[];
int r;
UINT4 t,l;
int rs=0;
Data d;
if(ssl->record_encryption==REC_CIPHERTEXT){
printf("\n");
return(0);
}
while(data->len>0){
SSL_DECODE_UINT8(ssl,0,0,data,&t);
SSL_DECODE_UINT24(ssl,0,0,data,&l);
if(data->len<l){
fprintf(stderr,"Error: short handshake length: expected %d got %d\n",
l,data->len);
ERETURN(R_EOD);
}
d.data=data->data;
d.len=l;
data->len-=l;
data->data+=l;
P_(P_HL){
if(!rs){
printf("\n");
rs=1;
}
}
ssl_decode_switch(ssl,HandshakeType_decoder,t,dir,seg,&d);
}
return(0);
@},
application_data(23)
{@
int r;
Data d;
SSL_DECODE_OPAQUE_ARRAY(ssl,"data",data->len,0,data,&d);
P_(P_AD){
print_data(ssl,&d);
}
else {
printf("\n");
}
return(0);
@}
, (255)
} ContentType;
select {
HelloRequest(0)
{@
printf("\n");
@},
ClientHello(1)
{@
UINT4 vj,vn,cs,cslen,complen,comp;
Data session_id,random;
int r;
extern decoder cipher_suite_decoder[];
extern decoder compression_method_decoder[];
printf("\n");
SSL_DECODE_UINT8(ssl,0,0,data,&vj);
SSL_DECODE_UINT8(ssl,0,0,data,&vn);
P_(P_HL) {explain(ssl,"Version %d.%d ",vj,vn);
printf("\n");
}
SSL_DECODE_OPAQUE_ARRAY(ssl,"random",32,P_ND,data,&random);
ssl_set_client_random(ssl->decoder,random.data,random.len);
SSL_DECODE_OPAQUE_ARRAY(ssl,"session_id",-32,0,data,&session_id);
ssl_set_client_session_id(ssl->decoder,session_id.data,session_id.len);
P_(P_HL){
if(session_id.len)
exdump(ssl,"resume ",&session_id);
}
P_(P_HL){
SSL_DECODE_UINT16(ssl,"cipher Suites len",0,data,&cslen);
explain(ssl,"cipher suites\n");
for(;cslen;cslen-=2){
ssl_decode_enum(ssl,0,2,cipher_suite_decoder,
0,data,&cs);
ssl_print_cipher_suite(ssl,(vj<<8)|vn,P_HL,cs);
printf("\n");
}
}
SSL_DECODE_UINT8(ssl,"compressionMethod len",0,data,&complen);
if(complen){
explain(ssl,"compression methods\n");
for(;complen;complen--){
SSL_DECODE_ENUM(ssl,0,1,compression_method_decoder,P_HL,data,&comp);
printf("\n");
}
}
return(0);
@},
ServerHello(2)
{@
int r;
Data rnd,session_id;
UINT4 vj,vn;
printf("\n");
SSL_DECODE_UINT8(ssl,0,0,data,&vj);
SSL_DECODE_UINT8(ssl,0,0,data,&vn);
ssl->version=vj*256+vn;
P_(P_HL) {explain(ssl,"Version %d.%d ",vj,vn);
printf("\n");
}
SSL_DECODE_OPAQUE_ARRAY(ssl,"random",32,P_ND,data,&rnd);
ssl_set_server_random(ssl->decoder,rnd.data,rnd.len);
SSL_DECODE_OPAQUE_ARRAY(ssl,"session_id",-32,P_HL,data,&session_id);
SSL_DECODE_ENUM(ssl,"cipherSuite",2,cipher_suite_decoder,
0,data,&ssl->cipher_suite);
P_(P_HL){
explain(ssl,"cipherSuite ");
ssl_print_cipher_suite(ssl,ssl->version,P_HL,ssl->cipher_suite);
}
ssl_find_cipher(ssl->cipher_suite,&ssl->cs);
ssl_process_server_session_id(ssl,ssl->decoder,session_id.data,
session_id.len);
P_(P_HL) printf("\n");
SSL_DECODE_ENUM(ssl,"compressionMethod",1,compression_method_decoder,P_HL,data,0);
P_(P_HL) printf("\n");
return(0);
@},
Certificate(11)
{@
UINT4 len;
Data cert;
int r;
printf("\n");
SSL_DECODE_UINT24(ssl,"certificates len",0,data,&len);
while(len){
SSL_DECODE_OPAQUE_ARRAY(ssl,"certificate",-((1<<23)-1),
0,data,&cert);
sslx_print_certificate(ssl,&cert,P_ND);
len-=(cert.len + 3);
}
return(0);
@},
ServerKeyExchange (12)
{@
int r;
printf("\n");
if(ssl->cs){
P_(P_ND){
explain(ssl,"params\n");
}
INDENT_INCR;
switch(ssl->cs->kex){
case KEX_DH:
SSL_DECODE_OPAQUE_ARRAY(ssl,"DH_p",-((1<<15)-1),P_ND,data,0);
SSL_DECODE_OPAQUE_ARRAY(ssl,"DH_g",-((1<<15)-1),P_ND,data,0);
SSL_DECODE_OPAQUE_ARRAY(ssl,"DH_Ys",-((1<<15)-1),P_ND,data,0);
break;
case KEX_RSA:
SSL_DECODE_OPAQUE_ARRAY(ssl,"RSA_modulus",-((1<<15)-1),P_ND,data,0);
SSL_DECODE_OPAQUE_ARRAY(ssl,"RSA_exponent",-((1<<15)-1),P_ND,data,0);
break;
}
INDENT_POP;
SSL_DECODE_OPAQUE_ARRAY(ssl,"signature",-((1<<15)-1),P_ND,data,0);
}
return(0);
@}
,
CertificateRequest(13)
{@
UINT4 len;
Data ca;
int r;
printf("\n");
SSL_DECODE_UINT8(ssl,"certificate_types len",0,data,&len);
for(;len;len--){
SSL_DECODE_ENUM(ssl,"certificate_types",1,
client_certificate_type_decoder, P_HL,data,0);
P_(P_HL){
printf("\n");
}
};
SSL_DECODE_UINT16(ssl,"certificate_authorities len",0,data,&len);
while(len){
SSL_DECODE_OPAQUE_ARRAY(ssl,"certificate_authorities",
-((1<<15)-1),0,data,&ca);
explain(ssl,"certificate_authority\n");
INDENT_INCR;
sslx_print_dn(ssl,&ca,P_HL);
INDENT_POP;
len-=(ca.len + 2);
}
return(0);
@}
, ServerHelloDone(14)
{@
printf("\n");
@},
CertificateVerify(15)
{@
int r;
printf("\n");
SSL_DECODE_OPAQUE_ARRAY(ssl,"Signature",-(1<<15-1),P_HL,data,0);
return(0);
@}
,
ClientKeyExchange(16)
{@
int r;
Data pms;
printf("\n");
if(ssl->cs){
switch(ssl->cs->kex){
case KEX_RSA:
if(ssl->version > 768) {
SSL_DECODE_OPAQUE_ARRAY(ssl,"EncryptedPreMasterSecret",-(1<<15-1),
P_ND,data,&pms);
}
else {
SSL_DECODE_OPAQUE_ARRAY(ssl,"EncryptedPreMasterSecret",data->len,P_ND,data,&pms);
}
ssl_process_client_key_exchange(ssl,
ssl->decoder,pms.data,pms.len);
break;
case KEX_DH:
SSL_DECODE_OPAQUE_ARRAY(ssl,"DiffieHellmanClientPublicValue",
-(1<<15-1),P_HL,data,0);
}
}
return(0);
@}
,
Finished(20)
{@
int r;
printf("\n");
switch(ssl->version){
case 0x300:
SSL_DECODE_OPAQUE_ARRAY(ssl,"md5_hash",16,P_ND,data,0);
SSL_DECODE_OPAQUE_ARRAY(ssl,"sha_hash",20,P_ND,data,0);
break;
case 0x301:
SSL_DECODE_OPAQUE_ARRAY(ssl,"verify_data",12,P_ND,data,0);
P_(P_ND)
printf("\n");
break;
}
return (0);
@}
, (255)
} HandshakeType;
constant {
// https://www.iana.org/assignments/tls-parameters/tls-parameters.txt
CipherSuite TLS_NULL_WITH_NULL_NULL = { 0x00,0x00 };
CipherSuite TLS_RSA_WITH_NULL_MD5 = { 0x00,0x01 };
CipherSuite TLS_RSA_WITH_NULL_SHA = { 0x00,0x02 };
CipherSuite TLS_RSA_EXPORT_WITH_RC4_40_MD5 = { 0x00,0x03 };
CipherSuite TLS_RSA_WITH_RC4_128_MD5 = { 0x00,0x04 };
CipherSuite TLS_RSA_WITH_RC4_128_SHA = { 0x00,0x05 };
CipherSuite TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 = { 0x00,0x06 };
CipherSuite TLS_RSA_WITH_IDEA_CBC_SHA = { 0x00,0x07 };
CipherSuite TLS_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x08 };
CipherSuite TLS_RSA_WITH_DES_CBC_SHA = { 0x00,0x09 };
CipherSuite TLS_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x0A };
CipherSuite TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x0B };
CipherSuite TLS_DH_DSS_WITH_DES_CBC_SHA = { 0x00,0x0C };
CipherSuite TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA = { 0x00,0x0D };
CipherSuite TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x0E };
CipherSuite TLS_DH_RSA_WITH_DES_CBC_SHA = { 0x00,0x0F };
CipherSuite TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x10 };
CipherSuite TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x11 };
CipherSuite TLS_DHE_DSS_WITH_DES_CBC_SHA = { 0x00,0x12 };
CipherSuite TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA = { 0x00,0x13 };
CipherSuite TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x14 };
CipherSuite TLS_DHE_RSA_WITH_DES_CBC_SHA = { 0x00,0x15 };
CipherSuite TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x16 };
CipherSuite TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 = { 0x00,0x17 };
CipherSuite TLS_DH_anon_WITH_RC4_128_MD5 = { 0x00,0x18 };
CipherSuite TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x19 };
CipherSuite TLS_DH_anon_WITH_DES_CBC_SHA = { 0x00,0x1A };
CipherSuite TLS_DH_anon_WITH_3DES_EDE_CBC_SHA = { 0x00,0x1B };
CipherSuite TLS_KRB5_WITH_DES_CBC_SHA = { 0x00,0x1E };
CipherSuite TLS_KRB5_WITH_3DES_EDE_CBC_SHA = { 0x00,0x1F };
CipherSuite TLS_KRB5_WITH_RC4_128_SHA = { 0x00,0x20 };
CipherSuite TLS_KRB5_WITH_IDEA_CBC_SHA = { 0x00,0x21 };
CipherSuite TLS_KRB5_WITH_DES_CBC_MD5 = { 0x00,0x22 };
CipherSuite TLS_KRB5_WITH_3DES_EDE_CBC_MD5 = { 0x00,0x23 };
CipherSuite TLS_KRB5_WITH_RC4_128_MD5 = { 0x00,0x24 };
CipherSuite TLS_KRB5_WITH_IDEA_CBC_MD5 = { 0x00,0x25 };
CipherSuite TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA = { 0x00,0x26 };
CipherSuite TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA = { 0x00,0x27 };
CipherSuite TLS_KRB5_EXPORT_WITH_RC4_40_SHA = { 0x00,0x28 };
CipherSuite TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 = { 0x00,0x29 };
CipherSuite TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 = { 0x00,0x2A };
CipherSuite TLS_KRB5_EXPORT_WITH_RC4_40_MD5 = { 0x00,0x2B };
CipherSuite TLS_PSK_WITH_NULL_SHA = { 0x00,0x2C };
CipherSuite TLS_DHE_PSK_WITH_NULL_SHA = { 0x00,0x2D };
CipherSuite TLS_RSA_PSK_WITH_NULL_SHA = { 0x00,0x2E };
CipherSuite TLS_RSA_WITH_AES_128_CBC_SHA = { 0x00,0x2F };
CipherSuite TLS_DH_DSS_WITH_AES_128_CBC_SHA = { 0x00,0x30 };
CipherSuite TLS_DH_RSA_WITH_AES_128_CBC_SHA = { 0x00,0x31 };
CipherSuite TLS_DHE_DSS_WITH_AES_128_CBC_SHA = { 0x00,0x32 };
CipherSuite TLS_DHE_RSA_WITH_AES_128_CBC_SHA = { 0x00,0x33 };
CipherSuite TLS_DH_anon_WITH_AES_128_CBC_SHA = { 0x00,0x34 };
CipherSuite TLS_RSA_WITH_AES_256_CBC_SHA = { 0x00,0x35 };
CipherSuite TLS_DH_DSS_WITH_AES_256_CBC_SHA = { 0x00,0x36 };
CipherSuite TLS_DH_RSA_WITH_AES_256_CBC_SHA = { 0x00,0x37 };
CipherSuite TLS_DHE_DSS_WITH_AES_256_CBC_SHA = { 0x00,0x38 };
CipherSuite TLS_DHE_RSA_WITH_AES_256_CBC_SHA = { 0x00,0x39 };
CipherSuite TLS_DH_anon_WITH_AES_256_CBC_SHA = { 0x00,0x3A };
CipherSuite TLS_RSA_WITH_NULL_SHA256 = { 0x00,0x3B };
CipherSuite TLS_RSA_WITH_AES_128_CBC_SHA256 = { 0x00,0x3C };
CipherSuite TLS_RSA_WITH_AES_256_CBC_SHA256 = { 0x00,0x3D };
CipherSuite TLS_DH_DSS_WITH_AES_128_CBC_SHA256 = { 0x00,0x3E };
CipherSuite TLS_DH_RSA_WITH_AES_128_CBC_SHA256 = { 0x00,0x3F };
CipherSuite TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = { 0x00,0x40 };
CipherSuite TLS_RSA_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x41 };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x42 };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x43 };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x44 };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x45 };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA = { 0x00,0x46 };
CipherSuite TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = { 0x00,0x67 };
CipherSuite TLS_DH_DSS_WITH_AES_256_CBC_SHA256 = { 0x00,0x68 };
CipherSuite TLS_DH_RSA_WITH_AES_256_CBC_SHA256 = { 0x00,0x69 };
CipherSuite TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 = { 0x00,0x6A };
CipherSuite TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = { 0x00,0x6B };
CipherSuite TLS_DH_anon_WITH_AES_128_CBC_SHA256 = { 0x00,0x6C };
CipherSuite TLS_DH_anon_WITH_AES_256_CBC_SHA256 = { 0x00,0x6D };
CipherSuite TLS_RSA_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x84 };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x85 };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x86 };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x87 };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x88 };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA = { 0x00,0x89 };
CipherSuite TLS_PSK_WITH_RC4_128_SHA = { 0x00,0x8A };
CipherSuite TLS_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00,0x8B };
CipherSuite TLS_PSK_WITH_AES_128_CBC_SHA = { 0x00,0x8C };
CipherSuite TLS_PSK_WITH_AES_256_CBC_SHA = { 0x00,0x8D };
CipherSuite TLS_DHE_PSK_WITH_RC4_128_SHA = { 0x00,0x8E };
CipherSuite TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00,0x8F };
CipherSuite TLS_DHE_PSK_WITH_AES_128_CBC_SHA = { 0x00,0x90 };
CipherSuite TLS_DHE_PSK_WITH_AES_256_CBC_SHA = { 0x00,0x91 };
CipherSuite TLS_RSA_PSK_WITH_RC4_128_SHA = { 0x00,0x92 };
CipherSuite TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00,0x93 };
CipherSuite TLS_RSA_PSK_WITH_AES_128_CBC_SHA = { 0x00,0x94 };
CipherSuite TLS_RSA_PSK_WITH_AES_256_CBC_SHA = { 0x00,0x95 };
CipherSuite TLS_RSA_WITH_SEED_CBC_SHA = { 0x00,0x96 };
CipherSuite TLS_DH_DSS_WITH_SEED_CBC_SHA = { 0x00,0x97 };
CipherSuite TLS_DH_RSA_WITH_SEED_CBC_SHA = { 0x00,0x98 };
CipherSuite TLS_DHE_DSS_WITH_SEED_CBC_SHA = { 0x00,0x99 };
CipherSuite TLS_DHE_RSA_WITH_SEED_CBC_SHA = { 0x00,0x9A };
CipherSuite TLS_DH_anon_WITH_SEED_CBC_SHA = { 0x00,0x9B };
CipherSuite TLS_RSA_WITH_AES_128_GCM_SHA256 = { 0x00,0x9C };
CipherSuite TLS_RSA_WITH_AES_256_GCM_SHA384 = { 0x00,0x9D };
CipherSuite TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = { 0x00,0x9E };
CipherSuite TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = { 0x00,0x9F };
CipherSuite TLS_DH_RSA_WITH_AES_128_GCM_SHA256 = { 0x00,0xA0 };
CipherSuite TLS_DH_RSA_WITH_AES_256_GCM_SHA384 = { 0x00,0xA1 };
CipherSuite TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 = { 0x00,0xA2 };
CipherSuite TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 = { 0x00,0xA3 };
CipherSuite TLS_DH_DSS_WITH_AES_128_GCM_SHA256 = { 0x00,0xA4 };
CipherSuite TLS_DH_DSS_WITH_AES_256_GCM_SHA384 = { 0x00,0xA5 };
CipherSuite TLS_DH_anon_WITH_AES_128_GCM_SHA256 = { 0x00,0xA6 };
CipherSuite TLS_DH_anon_WITH_AES_256_GCM_SHA384 = { 0x00,0xA7 };
CipherSuite TLS_PSK_WITH_AES_128_GCM_SHA256 = { 0x00,0xA8 };
CipherSuite TLS_PSK_WITH_AES_256_GCM_SHA384 = { 0x00,0xA9 };
CipherSuite TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 = { 0x00,0xAA };
CipherSuite TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 = { 0x00,0xAB };
CipherSuite TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 = { 0x00,0xAC };
CipherSuite TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 = { 0x00,0xAD };
CipherSuite TLS_PSK_WITH_AES_128_CBC_SHA256 = { 0x00,0xAE };
CipherSuite TLS_PSK_WITH_AES_256_CBC_SHA384 = { 0x00,0xAF };
CipherSuite TLS_PSK_WITH_NULL_SHA256 = { 0x00,0xB0 };
CipherSuite TLS_PSK_WITH_NULL_SHA384 = { 0x00,0xB1 };
CipherSuite TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 = { 0x00,0xB2 };
CipherSuite TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 = { 0x00,0xB3 };
CipherSuite TLS_DHE_PSK_WITH_NULL_SHA256 = { 0x00,0xB4 };
CipherSuite TLS_DHE_PSK_WITH_NULL_SHA384 = { 0x00,0xB5 };
CipherSuite TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 = { 0x00,0xB6 };
CipherSuite TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 = { 0x00,0xB7 };
CipherSuite TLS_RSA_PSK_WITH_NULL_SHA256 = { 0x00,0xB8 };
CipherSuite TLS_RSA_PSK_WITH_NULL_SHA384 = { 0x00,0xB9 };
CipherSuite TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBA };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBB };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBC };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBD };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBE };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 = { 0x00,0xBF };
CipherSuite TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC0 };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC1 };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC2 };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC3 };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC4 };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 = { 0x00,0xC5 };
CipherSuite TLS_EMPTY_RENEGOTIATION_INFO_SCSV = { 0x00,0xFF };
CipherSuite TLS_ECDH_ECDSA_WITH_NULL_SHA = { 0xC0,0x01 };
CipherSuite TLS_ECDH_ECDSA_WITH_RC4_128_SHA = { 0xC0,0x02 };
CipherSuite TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x03 };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = { 0xC0,0x04 };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = { 0xC0,0x05 };
CipherSuite TLS_ECDHE_ECDSA_WITH_NULL_SHA = { 0xC0,0x06 };
CipherSuite TLS_ECDHE_ECDSA_WITH_RC4_128_SHA = { 0xC0,0x07 };
CipherSuite TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x08 };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = { 0xC0,0x09 };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = { 0xC0,0x0A };
CipherSuite TLS_ECDH_RSA_WITH_NULL_SHA = { 0xC0,0x0B };
CipherSuite TLS_ECDH_RSA_WITH_RC4_128_SHA = { 0xC0,0x0C };
CipherSuite TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x0D };
CipherSuite TLS_ECDH_RSA_WITH_AES_128_CBC_SHA = { 0xC0,0x0E };
CipherSuite TLS_ECDH_RSA_WITH_AES_256_CBC_SHA = { 0xC0,0x0F };
CipherSuite TLS_ECDHE_RSA_WITH_NULL_SHA = { 0xC0,0x10 };
CipherSuite TLS_ECDHE_RSA_WITH_RC4_128_SHA = { 0xC0,0x11 };
CipherSuite TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x12 };
CipherSuite TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = { 0xC0,0x13 };
CipherSuite TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = { 0xC0,0x14 };
CipherSuite TLS_ECDH_anon_WITH_NULL_SHA = { 0xC0,0x15 };
CipherSuite TLS_ECDH_anon_WITH_RC4_128_SHA = { 0xC0,0x16 };
CipherSuite TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x17 };
CipherSuite TLS_ECDH_anon_WITH_AES_128_CBC_SHA = { 0xC0,0x18 };
CipherSuite TLS_ECDH_anon_WITH_AES_256_CBC_SHA = { 0xC0,0x19 };
CipherSuite TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x1A };
CipherSuite TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x1B };
CipherSuite TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x1C };
CipherSuite TLS_SRP_SHA_WITH_AES_128_CBC_SHA = { 0xC0,0x1D };
CipherSuite TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA = { 0xC0,0x1E };
CipherSuite TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA = { 0xC0,0x1F };
CipherSuite TLS_SRP_SHA_WITH_AES_256_CBC_SHA = { 0xC0,0x20 };
CipherSuite TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA = { 0xC0,0x21 };
CipherSuite TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA = { 0xC0,0x22 };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = { 0xC0,0x23 };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = { 0xC0,0x24 };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = { 0xC0,0x25 };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = { 0xC0,0x26 };
CipherSuite TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = { 0xC0,0x27 };
CipherSuite TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = { 0xC0,0x28 };
CipherSuite TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = { 0xC0,0x29 };
CipherSuite TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = { 0xC0,0x2A };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = { 0xC0,0x2B };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = { 0xC0,0x2C };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = { 0xC0,0x2D };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = { 0xC0,0x2E };
CipherSuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = { 0xC0,0x2F };
CipherSuite TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = { 0xC0,0x30 };
CipherSuite TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = { 0xC0,0x31 };
CipherSuite TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = { 0xC0,0x32 };
CipherSuite TLS_ECDHE_PSK_WITH_RC4_128_SHA = { 0xC0,0x33 };
CipherSuite TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA = { 0xC0,0x34 };
CipherSuite TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA = { 0xC0,0x35 };
CipherSuite TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA = { 0xC0,0x36 };
CipherSuite TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 = { 0xC0,0x37 };
CipherSuite TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 = { 0xC0,0x38 };
CipherSuite TLS_ECDHE_PSK_WITH_NULL_SHA = { 0xC0,0x39 };
CipherSuite TLS_ECDHE_PSK_WITH_NULL_SHA256 = { 0xC0,0x3A };
CipherSuite TLS_ECDHE_PSK_WITH_NULL_SHA384 = { 0xC0,0x3B };
CipherSuite TLS_RSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x3C };
CipherSuite TLS_RSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x3D };
CipherSuite TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x3E };
CipherSuite TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x3F };
CipherSuite TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x40 };
CipherSuite TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x41 };
CipherSuite TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x42 };
CipherSuite TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x43 };
CipherSuite TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x44 };
CipherSuite TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x45 };
CipherSuite TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x46 };
CipherSuite TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x47 };
CipherSuite TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x48 };
CipherSuite TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x49 };
CipherSuite TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x4A };
CipherSuite TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x4B };
CipherSuite TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x4C };
CipherSuite TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x4D };
CipherSuite TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x4E };
CipherSuite TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x4F };
CipherSuite TLS_RSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x50 };
CipherSuite TLS_RSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x51 };
CipherSuite TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x52 };
CipherSuite TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x53 };
CipherSuite TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x54 };
CipherSuite TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x55 };
CipherSuite TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x56 };
CipherSuite TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x57 };
CipherSuite TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x58 };
CipherSuite TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x59 };
CipherSuite TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x5A };
CipherSuite TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x5B };
CipherSuite TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x5C };
CipherSuite TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x5D };
CipherSuite TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x5E };
CipherSuite TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x5F };
CipherSuite TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x60 };
CipherSuite TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x61 };
CipherSuite TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x62 };
CipherSuite TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x63 };
CipherSuite TLS_PSK_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x64 };
CipherSuite TLS_PSK_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x65 };
CipherSuite TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x66 };
CipherSuite TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x67 };
CipherSuite TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x68 };
CipherSuite TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x69 };
CipherSuite TLS_PSK_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x6A };
CipherSuite TLS_PSK_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x6B };
CipherSuite TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x6C };
CipherSuite TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x6D };
CipherSuite TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 = { 0xC0,0x6E };
CipherSuite TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 = { 0xC0,0x6F };
CipherSuite TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 = { 0xC0,0x70 };
CipherSuite TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 = { 0xC0,0x71 };
CipherSuite TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x72 };
CipherSuite TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x73 };
CipherSuite TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x74 };
CipherSuite TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x75 };
CipherSuite TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x76 };
CipherSuite TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x77 };
CipherSuite TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x78 };
CipherSuite TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x79 };
CipherSuite TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x7A };
CipherSuite TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x7B };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x7C };
CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x7D };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x7E };
CipherSuite TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x7F };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x80 };
CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x81 };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x82 };
CipherSuite TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x83 };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x84 };
CipherSuite TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x85 };
CipherSuite TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x86 };
CipherSuite TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x87 };
CipherSuite TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x88 };
CipherSuite TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x89 };
CipherSuite TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x8A };
CipherSuite TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x8B };
CipherSuite TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x8C };
CipherSuite TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x8D };
CipherSuite TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x8E };
CipherSuite TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x8F };
CipherSuite TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x90 };
CipherSuite TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x91 };
CipherSuite TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 = { 0xC0,0x92 };
CipherSuite TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 = { 0xC0,0x93 };
CipherSuite TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x94 };
CipherSuite TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x95 };
CipherSuite TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x96 };
CipherSuite TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x97 };
CipherSuite TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x98 };
CipherSuite TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x99 };
CipherSuite TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 = { 0xC0,0x9A };
CipherSuite TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 = { 0xC0,0x9B };
CipherSuite TLS_RSA_WITH_AES_128_CCM = { 0xC0,0x9C };
CipherSuite TLS_RSA_WITH_AES_256_CCM = { 0xC0,0x9D };
CipherSuite TLS_DHE_RSA_WITH_AES_128_CCM = { 0xC0,0x9E };
CipherSuite TLS_DHE_RSA_WITH_AES_256_CCM = { 0xC0,0x9F };
CipherSuite TLS_RSA_WITH_AES_128_CCM_8 = { 0xC0,0xA0 };
CipherSuite TLS_RSA_WITH_AES_256_CCM_8 = { 0xC0,0xA1 };
CipherSuite TLS_DHE_RSA_WITH_AES_128_CCM_8 = { 0xC0,0xA2 };
CipherSuite TLS_DHE_RSA_WITH_AES_256_CCM_8 = { 0xC0,0xA3 };
CipherSuite TLS_PSK_WITH_AES_128_CCM = { 0xC0,0xA4 };
CipherSuite TLS_PSK_WITH_AES_256_CCM = { 0xC0,0xA5 };
CipherSuite TLS_DHE_PSK_WITH_AES_128_CCM = { 0xC0,0xA6 };
CipherSuite TLS_DHE_PSK_WITH_AES_256_CCM = { 0xC0,0xA7 };
CipherSuite TLS_PSK_WITH_AES_128_CCM_8 = { 0xC0,0xA8 };
CipherSuite TLS_PSK_WITH_AES_256_CCM_8 = { 0xC0,0xA9 };
CipherSuite TLS_PSK_DHE_WITH_AES_128_CCM_8 = { 0xC0,0xAA };
CipherSuite TLS_PSK_DHE_WITH_AES_256_CCM_8 = { 0xC0,0xAB };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CCM = { 0xC0,0xAC };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CCM = { 0xC0,0xAD };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 = { 0xC0,0xAE };
CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 = { 0xC0,0xAF };
CipherSuite TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xA8 };
CipherSuite TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xA9 };
CipherSuite TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xAA };
CipherSuite TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xAB };
CipherSuite TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xAC };
CipherSuite TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xAD };
CipherSuite TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 = { 0xCC,0xAE };
CipherSuite TLS_FALLBACK_SCSV = { 0x56,0x00 };
// New PSK ciphers introduced by TLS 1.3
// https://tlswg.github.io/tls13-spec/#rfc.appendix.A.4
CipherSuite TLS_AES_128_GCM_SHA256 = { 0x13,0x01 };
CipherSuite TLS_AES_256_GCM_SHA384 = { 0x13,0x02 };
CipherSuite TLS_CHACHA20_POLY1305_SHA256 = { 0x13,0x03 };
CipherSuite TLS_AES_128_CCM_SHA256 = { 0x13,0x04 };
CipherSuite TLS_AES_128_CCM_8_SHA256 = { 0x13,0x05 };
// DRAFT-IETF-TLS-ECC
CipherSuite TLS_ECDH_ECDSA_WITH_NULL_SHA = { 0x00,0x47 };
CipherSuite TLS_ECDH_ECDSA_WITH_RC4_128_SHA = { 0x00,0x48 };
CipherSuite TLS_ECDH_ECDSA_WITH_DES_CBC_SHA = { 0x00,0x49 };
CipherSuite TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x4A };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = { 0x00,0x4B };
CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = { 0x00,0x4C };
CipherSuite TLS_ECDH_ECDSA_EXPORT_WITH_RC4_40_SHA = { 0x00,0x4B };
CipherSuite TLS_ECDH_ECDSA_EXPORT_WITH_RC4_56_SHA = { 0x00,0x4C };
CipherSuite TLS_ECDH_RSA_WITH_NULL_SHA = { 0x00,0x4D };
CipherSuite TLS_ECDH_RSA_WITH_RC4_128_SHA = { 0x00,0x4E };
CipherSuite TLS_ECDH_RSA_WITH_DES_CBC_SHA = { 0x00,0x4F };
CipherSuite TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA = { 0x00,0x50 };
CipherSuite TLS_ECDH_RSA_WITH_AES_128_CBC_SHA = { 0x00,0x51 };
CipherSuite TLS_ECDH_RSA_WITH_AES_256_CBC_SHA = { 0x00,0x52 };
CipherSuite TLS_ECDH_RSA_EXPORT_WITH_RC4_40_SHA = { 0x00,0x53 };
CipherSuite TLS_ECDH_RSA_EXPORT_WITH_RC4_56_SHA = { 0x00,0x54 };
CipherSuite TLS_ECDH_anon_NULL_WITH_SHA = { 0x00,0x55 };
CipherSuite TLS_ECDH_anon_WITH_RC4_128_SHA = { 0x00,0x56 };
CipherSuite TLS_ECDH_anon_WITH_DES_CBC_SHA = { 0x00,0x57 };
CipherSuite TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA = { 0x00,0x58 };
CipherSuite TLS_ECDH_anon_EXPORT_WITH_DES40_CBC_SHA = { 0x00,0x59 };
CipherSuite TLS_ECDH_anon_EXPORT_WITH_RC4_40_SHA = { 0x00,0x5A };
// DRAFT-IETF-TLS-56-BIT-CIPHERSUITES
CipherSuite TLS_RSA_EXPORT1024_WITH_RC4_56_MD5 = { 0x00,0x60 };
CipherSuite TLS_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5 = { 0x00,0x61 };
CipherSuite TLS_RSA_EXPORT1024_WITH_DES_CBC_SHA = { 0x00,0x62 };
CipherSuite TLS_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA = { 0x00,0x63 };
CipherSuite TLS_RSA_EXPORT1024_WITH_RC4_56_SHA = { 0x00,0x64 };
CipherSuite TLS_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA = { 0x00,0x65 };
CipherSuite TLS_DHE_DSS_WITH_RC4_128_SHA = { 0x00,0x66 };
// FIPS SSL (Netscape)
CipherSuite SSL_RSA_FIPS_WITH_DES_CBC_SHA = { 0xFE,0xFE };
CipherSuite SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA = { 0xFE,0xFF };
// SSL 2.0
CipherSuite SSL2_RC4_128_WITH_MD5 = { 0x01,0x00,0x80 };
CipherSuite SSL2_RC4_128_EXPORT40_WITH_MD5 = { 0x02,0x00,0x80 };
CipherSuite SSL2_RC2_CBC_128_CBC_WITH_MD5 = { 0x03,0x00,0x80 };
CipherSuite SSL2_RC2_128_CBC_EXPORT40_WITH_MD5 = { 0x04,0x00,0x80 };
CipherSuite SSL2_IDEA_128_CBC_WITH_MD5 = { 0x05,0x00,0x80 };
CipherSuite SSL2_DES_64_CBC_WITH_MD5 = { 0x06,0x00,0x40 };
CipherSuite SSL2_DES_64_CBC_WITH_SHA = { 0x06,0x01,0x40 };
CipherSuite SSL2_DES_192_EDE3_CBC_WITH_MD5 = { 0x07,0x00,0xc0 };
CipherSuite SSL2_DES_192_EDE3_CBC_WITH_SHA = { 0x07,0x01,0xc0 };
CipherSuite SSL2_RC4_64_WITH_MD5 = { 0x08,0x00,0x80 };
} cipher_suite;
select { warning(1), fatal(2), (255) } AlertLevel;
select {
close_notify(0),
unexpected_message(10),
bad_record_mac(20),
decryption_failed(21),
record_overflow(22),
decompression_failure(30),
handshake_failure(40),
bad_certificate(42),
unsupported_certificate(43),
certificate_revoked(44),
certificate_expired(45),
certificate_unknown(46),
illegal_parameter(47),
unknown_ca(48),
access_denied(49),
decode_error(50),
decrypt_error(51),
export_restriction(60),
protocol_version(70),
insufficient_security(71),
internal_error(80),
user_canceled(90),
no_renegotiation(100),
(255)
} AlertDescription;
constant {
CompressionMethod NULL={0};
} compression_method;
select {
rsa_sign(1), dss_sign(2), rsa_fixed_dh(3), dss_fixed_dh(4),
(255)
} client_certificate_type;

67
ssl/Attic/ssl.l
View file

@ -1,67 +0,0 @@
%option yylineno
%{
#include "y.tab.h"
#if 0
#define RETURN(x) printf("TOK:%s\n",#x); return(x)
#else
#define RETURN return
#endif
long strtol();
%}
IDCHAR [a-zA-Z0-9_\-\.]
NUMCHAR [0-9]
S [ \t\n\r\f]+
NAME [a-zA-Z]{IDCHAR}+
NUM {NUMCHAR}+
HEXNUM "0x"[0-9A-Za-z]+
COMMENT "/*"("*"?[^/]+)*("*/")
CODE "{@"[^@]+"@}"
%%
".." {RETURN(DOT_DOT_);}
"enum" {RETURN(ENUM_);}
"struct" {RETURN(STRUCT_);}
"opaque" {mkname();RETURN(OPAQUE_);}
"select" {RETURN(SELECT_);}
"constant" {RETURN(CONSTANT_);}
"digitally-signed" {/* Do nothing*/}
"public-key-encrypted" {/* Do nothing*/}
"case" {RETURN(CASE_);}
{COMMENT} { /*Do nothing*/}
{CODE} { strcpy(yylval.str,yytext); RETURN(CODE_);}
{S} {/*do nothing*/}
{NAME} {mkname();RETURN(NAME_);}
{NUM} {yylval.val=atoi(yytext); RETURN(NUM_);}
{HEXNUM} {yylval.val=strtol(yytext,0,16); RETURN(NUM_);}
"{" { RETURN('{'); }
"}" { RETURN('}'); }
"(" { RETURN('('); }
")" { RETURN(')'); }
"[" { RETURN('['); }
"]" { RETURN(']'); }
"<" { RETURN('<'); }
">" { RETURN('>'); }
";" { RETURN(';'); }
":" { RETURN(':'); }
"," { RETURN(','); }
"." { RETURN('.'); }
"^" { RETURN('^'); }
"-" { RETURN('-'); }
"=" { RETURN('='); }
. { fprintf(stderr,"Invalid input token: %s at %d!!!\n",yytext,yylineno);
exit(1);
}
%%
int mkname()
{
#if 0
printf("%s\n",yytext);
#endif
strcpy(yylval.str,yytext);
}

241
ssl/Attic/ssl.y
View file

@ -1,241 +0,0 @@
/**
ssl.y
Copyright (C) 1998, RTFM, Inc.
All Rights Reserved.
ekr@rtfm.com Fri Dec 25 20:33:47 1998
*/
%{
typedef struct select_st_ {
char *name;
char *code;
int val;
struct select_st_ *next;
} select_st;
select_st *select_base;
select_st *select_ptr;
select_st *constant_base;
select_st *constant_ptr;
#include <stdio.h>
extern FILE *dotc;
extern FILE *doth;
%}
%union {
int val;
unsigned char str[8192];
}
/*These tokens have attributes*/
%token <str> NAME_
%token <val> NUM_
/*Tokens*/
%token <val> DOT_DOT_
%token <val> STRUCT_
%token <val> SELECT_
%token <str> OPAQUE_
%token <val> SELECT_
%token <val> ENUM_
%token <val> DIGITALLY_SIGNED_
%token <val> COMMENT_START_
%token <str> CODE_
%token <val> COMMENT_END_
%token <val> CASE_
%token <val> CONSTANT_
/*Types for nonterminals*/
%type <val> module
%type <val> typelist
%type <val> definition
%type <val> selecttype
%type <val> constant_type
%type <val> selecterateds
%type <val> selectmax
%type <val> constval
/*%type <val> selecterated*/
%%
module: typelist
typelist: {$$=1};
| definition typelist
{
$$=1;
}
;
definition: selecttype
| constant_type
;
selecttype: SELECT_ '{' selecterateds ',' selectmax '}' NAME_ ';'
{
select_st *en;
char filename[100];
for(en=select_base;en;en=en->next){
fprintf(dotc,"static int decode_%s_%s(ssl,dir,seg,data)\n",
$7,en->name);
fprintf(dotc," ssl_obj *ssl;\n");
fprintf(dotc," int dir;\n");
fprintf(dotc," segment *seg;\n");
fprintf(dotc," Data *data;\n");
fprintf(dotc," {\n");
if(en->code){
en->code+=2;
en->code[strlen(en->code)-2]=0;
fprintf(dotc,"\n%s\n",en->code);
}
else{
/* fprintf(dotc," fprintf(dotc,\"Decoding %s...%cn\");\n",en->name,'\\');*/
fprintf(dotc," return(0);\n");
}
fprintf(dotc," }\n");
}
fprintf(dotc,"decoder %s_decoder[]={\n",$7);
fprintf(doth,"extern decoder %s_decoder[];\n",$7);
for(en=select_base;en;en=en->next){
fprintf(dotc," {\n");
fprintf(dotc," %d,\n",en->val);
fprintf(dotc," \"%s\",\n",en->name);
fprintf(dotc," decode_%s_%s\n",$7,en->name);
fprintf(dotc," },\n");
}
fprintf(dotc,"{-1}\n");
fprintf(dotc,"};\n\n");
select_base=0;
}
;
selecterateds: selecterateds ',' selecterated
| selecterated
{;
}
;
selectmax: '(' NUM_ ')'
{$$=1;};
selecterated: selecterated_no_code
| selecterated_code
;
selecterated_code: NAME_ '(' NUM_ ')' CODE_
{
select_st *en;
en=malloc(sizeof(select_st));
en->next=0;
en->val=$3;
en->name=strdup($1);
en->code=strdup($5);
if(!select_base){
select_base=en;
select_ptr=en;
}
else{
select_ptr->next=en;
select_ptr=en;
}
};
selecterated_no_code: NAME_ '(' NUM_ ')'
{
select_st *en;
en=malloc(sizeof(select_st));
en->next=0;
en->val=$3;
en->name=strdup($1);
en->code=0;
if(!select_base){
select_base=en;
select_ptr=en;
}
else{
select_ptr->next=en;
select_ptr=en;
}
};
constant_type: CONSTANT_ '{' constants '}' NAME_ ';'
{
select_st *en;
fprintf(dotc,"decoder %s_decoder[]={\n",$5);
fprintf(doth,"extern decoder %s_decoder[];\n",$5);
for(en=constant_base;en;en=en->next){
fprintf(dotc," {\n");
fprintf(dotc," %d,\n",en->val);
fprintf(dotc," \"%s\",\n",en->name);
fprintf(dotc," 0");
fprintf(dotc," },\n");
}
fprintf(dotc,"{-1}\n");
fprintf(dotc,"};\n\n");
constant_ptr=0;
constant_base=0;
}
constants: constants constant
| constant
{;
}
;
constant: NAME_ NAME_ '=' '{' constval '}' ';'
{
select_st *en;
en=malloc(sizeof(select_st));
en->next=0;
en->val=$5;
en->name=strdup($2);
if(!constant_base){
constant_base=en;
constant_ptr=en;
}
else{
constant_ptr->next=en;
constant_ptr=en;
}
};
constval: NUM_ ',' NUM_ ',' NUM_
{
$$=($1 << 16) | ($3 << 8) | $5;
}
| NUM_ ',' NUM_
{
$$=($1 << 8) | $3;
}
| NUM_
{
$$=$1;
}
;

385
ssl/Attic/ssl_enum.c
View file

@ -1,385 +0,0 @@
#include "network.h"
#include "ssl.h"
#include "sslprint.h"
static int decode_ContentType_change_cipher_spec(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_ContentType_alert(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_ContentType_handshake(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
extern decoder HandshakeType_decoder[];
int r;
UINT4 t,l;
SSL_DECODE_UINT8(ssl,0,0,data,&t);
SSL_DECODE_UINT24(ssl,0,0,data,&l);
if(data->len!=l){
fprintf(stderr,"Error: short handshake length: expected %d got %d\n",
l,data->len);
ERETURN(R_EOD);
}
ssl_decode_switch(ssl,HandshakeType_decoder,t,dir,seg,data);
}
static int decode_ContentType_application_data(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
decoder ContentType_decoder[]={
{
20,
"change_cipher_spec",
decode_ContentType_change_cipher_spec
},
{
21,
"alert",
decode_ContentType_alert
},
{
22,
"handshake",
decode_ContentType_handshake
},
{
23,
"application_data",
decode_ContentType_application_data
},
{-1}
};
static int decode_HandshakeType_hello_request(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_client_hello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
UINT4 vj,vn,cs,cslen,complen,comp;
Data session_id,random;
int r;
extern decoder cipher_suite_decoder[];
extern decoder compression_method_decoder[];
SSL_DECODE_UINT8(ssl,0,0,data,&vj);
SSL_DECODE_UINT8(ssl,0,0,data,&vn);
P_(P_ND) {explain(ssl,"Client version %d.%d ",vj,vn);}
printf("\n");
SSL_DECODE_OPAQUE_ARRAY(ssl,"random",32,P_ND,data,&random);
SSL_DECODE_OPAQUE_ARRAY(ssl,"session_id",-32,0,data,&session_id);
if(session_id.len)
exdump(ssl,"resume ",&session_id);
SSL_DECODE_UINT16(ssl,"cipher Suites len",0,data,&cslen);
explain(ssl,"cipher suites\n");
for(;cslen;cslen-=2){
SSL_DECODE_ENUM(ssl,0,2,cipher_suite_decoder,
P_HL,data,&cs);
printf("\n");
}
SSL_DECODE_UINT8(ssl,"compressionMethod len",0,data,&complen);
if(complen){
explain(ssl,"compression methods\n");
for(;complen;complen--){
SSL_DECODE_ENUM(ssl,0,1,compression_method_decoder,P_HL,data,&comp);
printf("\n");
}
}
return(0);
}
static int decode_HandshakeType_server_hello(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
int r;
UINT4 vj,vn;
SSL_DECODE_UINT8(ssl,0,0,data,&vj);
SSL_DECODE_UINT8(ssl,0,0,data,&vn);
P_(P_ND) {explain(ssl,"SSL version %d.%d ",vj,vn);}
SSL_DECODE_OPAQUE_ARRAY(ssl,"random",32,P_ND,data,0);
SSL_DECODE_OPAQUE_ARRAY(ssl,"session_id",32,P_ND,data,0);
SSL_DECODE_ENUM(ssl,0,2,cipher_suite_decoder,
P_HL,data,0);
SSL_DECODE_ENUM(ssl,0,1,compression_method_decoder,P_HL,data,0);
return(0);
}
static int decode_HandshakeType_certificate(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_server_key_exchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_certificate_request(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_server_hello_done(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_certificate_verify(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_client_key_exchange(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
static int decode_HandshakeType_finished(ssl,dir,seg,data)
ssl_obj *ssl;
int dir;
segment *seg;
Data *data;
{
return(0);
}
decoder HandshakeType_decoder[]={
{
0,
"hello_request",
decode_HandshakeType_hello_request
},
{
1,
"client_hello",
decode_HandshakeType_client_hello
},
{
2,
"server_hello",
decode_HandshakeType_server_hello
},
{
11,
"certificate",
decode_HandshakeType_certificate
},
{
12,
"server_key_exchange",
decode_HandshakeType_server_key_exchange
},
{
13,
"certificate_request",
decode_HandshakeType_certificate_request
},
{
14,
"server_hello_done",
decode_HandshakeType_server_hello_done
},
{
15,
"certificate_verify",
decode_HandshakeType_certificate_verify
},
{
16,
"client_key_exchange",
decode_HandshakeType_client_key_exchange
},
{
20,
"finished",
decode_HandshakeType_finished
},
{-1}
};
decoder cipher_suite_decoder[]={
{
1,
"TLS_RSA_WITH_NULL_MD5",
0 },
{
2,
"TLS_RSA_WITH_NULL_SHA",
0 },
{
3,
"TLS_RSA_EXPORT_WITH_RC4_40_MD5",
0 },
{
4,
"TLS_RSA_WITH_RC4_128_MD5",
0 },
{
5,
"TLS_RSA_WITH_RC4_128_SHA",
0 },
{
6,
"TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5",
0 },
{
7,
"TLS_RSA_WITH_IDEA_CBC_SHA",
0 },
{
8,
"TLS_RSA_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
9,
"TLS_RSA_WITH_DES_CBC_SHA",
0 },
{
10,
"TLS_RSA_WITH_3DES_EDE_CBC_SHA",
0 },
{
11,
"TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
12,
"TLS_DH_DSS_WITH_DES_CBC_SHA",
0 },
{
13,
"TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA",
0 },
{
14,
"TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
15,
"TLS_DH_RSA_WITH_DES_CBC_SHA",
0 },
{
16,
"TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA",
0 },
{
17,
"TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
18,
"TLS_DHE_DSS_WITH_DES_CBC_SHA",
0 },
{
19,
"TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA",
0 },
{
20,
"TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
21,
"TLS_DHE_RSA_WITH_DES_CBC_SHA",
0 },
{
22,
"TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA",
0 },
{
23,
"TLS_DH_anon_EXPORT_WITH_RC4_40_MD5",
0 },
{
24,
"TLS_DH_anon_WITH_RC4_128_MD5",
0 },
{
25,
"TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA",
0 },
{
26,
"TLS_DH_anon_WITH_DES_CBC_SHA",
0 },
{
27,
"TLS_DH_anon_WITH_3DES_EDE_CBC_SHA",
0 },
{-1}
};
decoder compression_method_decoder[]={
{
7,
"NULL",
0 },
{-1}
};

1124
ssl/Attic/y.tab.c
View file

File diff suppressed because it is too large Load diff

20
ssl/Attic/y.tab.h
View file

@ -1,20 +0,0 @@
typedef union {
int val;
unsigned char str[8192];
} YYSTYPE;
#define NAME_ 257
#define NUM_ 258
#define DOT_DOT_ 259
#define STRUCT_ 260
#define SELECT_ 261
#define OPAQUE_ 262
#define ENUM_ 263
#define DIGITALLY_SIGNED_ 264
#define COMMENT_START_ 265
#define CODE_ 266
#define COMMENT_END_ 267
#define CASE_ 268
#define CONSTANT_ 269
extern YYSTYPE yylval;

392
ssl/ciphersuites.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ciphersuites.c,v 1.3 2002/08/17 01:33:17 ekr Exp $ $Id: ciphersuites.c,v 1.3 2002/08/17 01:33:17 ekr Exp $
@ -43,210 +44,203 @@
ekr@rtfm.com Tue Mar 30 17:19:56 1999 ekr@rtfm.com Tue Mar 30 17:19:56 1999
*/ */
#include <r_common.h> #include <r_common.h>
#include "sslciphers.h" #include "sslciphers.h"
static SSL_CipherSuite CipherSuites[]={ static SSL_CipherSuite CipherSuites[] = {
{1,KEX_RSA,SIG_RSA,ENC_NULL,0,0,0,DIG_MD5,16,0}, {1, KEX_RSA, SIG_RSA, ENC_NULL, 0, 0, 0, DIG_MD5, 16, 0},
{2,KEX_RSA,SIG_RSA,ENC_NULL,0,0,0,DIG_SHA,20,0}, {2, KEX_RSA, SIG_RSA, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{3,KEX_RSA,SIG_RSA,ENC_RC4,1,128,40,DIG_MD5,16,1}, {3, KEX_RSA, SIG_RSA, ENC_RC4, 1, 128, 40, DIG_MD5, 16, 1},
{4,KEX_RSA,SIG_RSA,ENC_RC4,1,128,128,DIG_MD5,16,0}, {4, KEX_RSA, SIG_RSA, ENC_RC4, 1, 128, 128, DIG_MD5, 16, 0},
{5,KEX_RSA,SIG_RSA,ENC_RC4,1,128,128,DIG_SHA,20,0}, {5, KEX_RSA, SIG_RSA, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{6,KEX_RSA,SIG_RSA,ENC_RC2,8,128,40,DIG_SHA,20,1}, {6, KEX_RSA, SIG_RSA, ENC_RC2, 8, 128, 40, DIG_SHA, 20, 1},
{7,KEX_RSA,SIG_RSA,ENC_IDEA,8,128,128,DIG_SHA,20,0}, {7, KEX_RSA, SIG_RSA, ENC_IDEA, 8, 128, 128, DIG_SHA, 20, 0},
{8,KEX_RSA,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1}, {8, KEX_RSA, SIG_RSA, ENC_DES, 8, 64, 40, DIG_SHA, 20, 1},
{9,KEX_RSA,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0}, {9, KEX_RSA, SIG_RSA, ENC_DES, 8, 64, 64, DIG_SHA, 20, 0},
{10,KEX_RSA,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0}, {10, KEX_RSA, SIG_RSA, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{11,KEX_DH,SIG_DSS,ENC_DES,8,64,40,DIG_SHA,20,1}, {11, KEX_DH, SIG_DSS, ENC_DES, 8, 64, 40, DIG_SHA, 20, 1},
{12,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,20,0}, {12, KEX_DH, SIG_DSS, ENC_DES, 8, 64, 64, DIG_SHA, 20, 0},
{13,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0}, {13, KEX_DH, SIG_DSS, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{14,KEX_DH,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1}, {14, KEX_DH, SIG_RSA, ENC_DES, 8, 64, 40, DIG_SHA, 20, 1},
{15,KEX_DH,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0}, {15, KEX_DH, SIG_RSA, ENC_DES, 8, 64, 64, DIG_SHA, 20, 0},
{16,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0}, {16, KEX_DH, SIG_RSA, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{17,KEX_DH,SIG_DSS,ENC_DES,8,64,40,DIG_SHA,20,1}, {17, KEX_DH, SIG_DSS, ENC_DES, 8, 64, 40, DIG_SHA, 20, 1},
{18,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,20,0}, {18, KEX_DH, SIG_DSS, ENC_DES, 8, 64, 64, DIG_SHA, 20, 0},
{19,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0}, {19, KEX_DH, SIG_DSS, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{20,KEX_DH,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1}, {20, KEX_DH, SIG_RSA, ENC_DES, 8, 64, 40, DIG_SHA, 20, 1},
{21,KEX_DH,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0}, {21, KEX_DH, SIG_RSA, ENC_DES, 8, 64, 64, DIG_SHA, 20, 0},
{22,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0}, {22, KEX_DH, SIG_RSA, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{23,KEX_DH,SIG_NONE,ENC_RC4,1,128,40,DIG_MD5,16,1}, {23, KEX_DH, SIG_NONE, ENC_RC4, 1, 128, 40, DIG_MD5, 16, 1},
{24,KEX_DH,SIG_NONE,ENC_RC4,1,128,128,DIG_MD5,16,0}, {24, KEX_DH, SIG_NONE, ENC_RC4, 1, 128, 128, DIG_MD5, 16, 0},
{25,KEX_DH,SIG_NONE,ENC_DES,8,64,40,DIG_MD5,16,1}, {25, KEX_DH, SIG_NONE, ENC_DES, 8, 64, 40, DIG_MD5, 16, 1},
{26,KEX_DH,SIG_NONE,ENC_DES,8,64,64,DIG_MD5,16,0}, {26, KEX_DH, SIG_NONE, ENC_DES, 8, 64, 64, DIG_MD5, 16, 0},
{27,KEX_DH,SIG_NONE,ENC_3DES,8,192,192,DIG_MD5,16,0}, {27, KEX_DH, SIG_NONE, ENC_3DES, 8, 192, 192, DIG_MD5, 16, 0},
// Missing: 44-46 // Missing: 44-46
{47,KEX_RSA,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA,20,0}, {47, KEX_RSA, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{48,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA,20,0}, {48, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{50,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA,20,0}, {50, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{51,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA,20,0}, {51, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{52,KEX_DH,SIG_NONE,ENC_AES128,16,128,128,DIG_SHA,20,0}, {52, KEX_DH, SIG_NONE, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{53,KEX_RSA,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0}, {53, KEX_RSA, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{54,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA,20,0}, {54, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{55,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0}, {55, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{56,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA,20,0}, {56, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{57,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0}, {57, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{58,KEX_DH,SIG_NONE,ENC_AES256,16,256,256,DIG_SHA,20,0}, {58, KEX_DH, SIG_NONE, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{59,KEX_RSA,SIG_RSA,ENC_NULL,0,0,0,DIG_SHA256,32,0}, {59, KEX_RSA, SIG_RSA, ENC_NULL, 0, 0, 0, DIG_SHA256, 32, 0},
{60,KEX_RSA,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {60, KEX_RSA, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{61,KEX_RSA,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {61, KEX_RSA, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{62,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {62, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{63,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {63, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{64,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {64, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{65,KEX_RSA,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {65, KEX_RSA, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{66,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {66, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{67,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {67, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{68,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {68, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{69,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {69, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{70,KEX_DH,SIG_NONE,ENC_CAMELLIA128,16,128,128,DIG_SHA,20,0}, {70, KEX_DH, SIG_NONE, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA, 20, 0},
{96,KEX_RSA,SIG_RSA,ENC_RC4,1,128,56,DIG_MD5,16,1}, {96, KEX_RSA, SIG_RSA, ENC_RC4, 1, 128, 56, DIG_MD5, 16, 1},
{97,KEX_RSA,SIG_RSA,ENC_RC2,1,128,56,DIG_MD5,16,1}, {97, KEX_RSA, SIG_RSA, ENC_RC2, 1, 128, 56, DIG_MD5, 16, 1},
{98,KEX_RSA,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,1}, {98, KEX_RSA, SIG_RSA, ENC_DES, 8, 64, 64, DIG_SHA, 20, 1},
{99,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,20,1}, {99, KEX_DH, SIG_DSS, ENC_DES, 8, 64, 64, DIG_SHA, 20, 1},
{100,KEX_RSA,SIG_RSA,ENC_RC4,1,128,56,DIG_SHA,20,1}, {100, KEX_RSA, SIG_RSA, ENC_RC4, 1, 128, 56, DIG_SHA, 20, 1},
{101,KEX_DH,SIG_DSS,ENC_RC4,1,128,56,DIG_SHA,20,1}, {101, KEX_DH, SIG_DSS, ENC_RC4, 1, 128, 56, DIG_SHA, 20, 1},
{102,KEX_DH,SIG_DSS,ENC_RC4,1,128,128,DIG_SHA,20,0}, {102, KEX_DH, SIG_DSS, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{103,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {103, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{104,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {104, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{105,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {105, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{106,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {106, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{107,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {107, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{108,KEX_DH,SIG_NONE,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {108, KEX_DH, SIG_NONE, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{109,KEX_DH,SIG_NONE,ENC_AES256,16,256,256,DIG_SHA256,32,0}, {109, KEX_DH, SIG_NONE, ENC_AES256, 16, 256, 256, DIG_SHA256, 32, 0},
{132,KEX_RSA,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {132, KEX_RSA, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
{133,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {133, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
{134,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {134, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
{135,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {135, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
{136,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {136, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
{137,KEX_DH,SIG_NONE,ENC_CAMELLIA256,16,256,256,DIG_SHA,20,0}, {137, KEX_DH, SIG_NONE, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA, 20, 0},
// Missing: 138-149 // Missing: 138-149
{150,KEX_RSA,SIG_RSA,ENC_SEED,16,128,128,DIG_SHA,20,0}, {150, KEX_RSA, SIG_RSA, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{151,KEX_DH,SIG_DSS,ENC_SEED,16,128,128,DIG_SHA,20,0}, {151, KEX_DH, SIG_DSS, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{152,KEX_DH,SIG_RSA,ENC_SEED,16,128,128,DIG_SHA,20,0}, {152, KEX_DH, SIG_RSA, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{153,KEX_DH,SIG_DSS,ENC_SEED,16,128,128,DIG_SHA,20,0}, {153, KEX_DH, SIG_DSS, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{154,KEX_DH,SIG_RSA,ENC_SEED,16,128,128,DIG_SHA,20,0}, {154, KEX_DH, SIG_RSA, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{155,KEX_DH,SIG_NONE,ENC_SEED,16,128,128,DIG_SHA,20,0}, {155, KEX_DH, SIG_NONE, ENC_SEED, 16, 128, 128, DIG_SHA, 20, 0},
{156,KEX_RSA,SIG_RSA,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {156, KEX_RSA, SIG_RSA, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{157,KEX_RSA,SIG_RSA,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {157, KEX_RSA, SIG_RSA, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{158,KEX_DH,SIG_RSA,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {158, KEX_DH, SIG_RSA, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{159,KEX_DH,SIG_RSA,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {159, KEX_DH, SIG_RSA, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{160,KEX_DH,SIG_RSA,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {160, KEX_DH, SIG_RSA, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{161,KEX_DH,SIG_RSA,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {161, KEX_DH, SIG_RSA, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{162,KEX_DH,SIG_DSS,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {162, KEX_DH, SIG_DSS, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{163,KEX_DH,SIG_DSS,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {163, KEX_DH, SIG_DSS, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{164,KEX_DH,SIG_DSS,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {164, KEX_DH, SIG_DSS, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{165,KEX_DH,SIG_DSS,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {165, KEX_DH, SIG_DSS, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{166,KEX_DH,SIG_NONE,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {166, KEX_DH, SIG_NONE, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{167,KEX_DH,SIG_NONE,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {167, KEX_DH, SIG_NONE, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
// Missing: 168-185 // Missing: 168-185
{186,KEX_RSA,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {186, KEX_RSA, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{187,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {187, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{188,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {188, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{189,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {189, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{190,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {190, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{191,KEX_DH,SIG_NONE,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {191, KEX_DH, SIG_NONE, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{192,KEX_RSA,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {192, KEX_RSA, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{193,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {193, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{194,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {194, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{195,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {195, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{196,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {196, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{197,KEX_DH,SIG_NONE,ENC_CAMELLIA256,16,256,256,DIG_SHA256,32,0}, {197, KEX_DH, SIG_NONE, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 32, 0},
{4865,KEX_DH,SIG_NONE,ENC_AES128_GCM,16,128,128,DIG_SHA256,32,0}, {4865, KEX_DH, SIG_NONE, ENC_AES128_GCM, 16, 128, 128, DIG_SHA256, 32, 0},
{4866,KEX_DH,SIG_NONE,ENC_AES256_GCM,16,256,256,DIG_SHA384,48,0}, {4866, KEX_DH, SIG_NONE, ENC_AES256_GCM, 16, 256, 256, DIG_SHA384, 48, 0},
{4867,KEX_DH,SIG_NONE,ENC_CHACHA20_POLY1305,64,256,256,DIG_SHA256,32,0}, {4867, KEX_DH, SIG_NONE, ENC_CHACHA20_POLY1305, 64, 256, 256, DIG_SHA256,
{4868,KEX_DH,SIG_NONE,ENC_AES128_CCM,16,128,128,DIG_SHA256,32,0}, 32, 0},
{4869,KEX_DH,SIG_NONE,ENC_AES128_CCM_8,16,128,128,DIG_SHA256,32,0}, {4868, KEX_DH, SIG_NONE, ENC_AES128_CCM, 16, 128, 128, DIG_SHA256, 32, 0},
{49153,KEX_DH,SIG_DSS,ENC_NULL,0,0,0,DIG_SHA,20,0}, {4869, KEX_DH, SIG_NONE, ENC_AES128_CCM_8, 16, 128, 128, DIG_SHA256, 32, 0},
{49154,KEX_DH,SIG_DSS,ENC_RC4,1,128,128,DIG_SHA,20,0}, {49153, KEX_DH, SIG_DSS, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{49155,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0}, {49154, KEX_DH, SIG_DSS, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{49156,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49155, KEX_DH, SIG_DSS, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{49157,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA,20,0}, {49156, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49158,KEX_DH,SIG_DSS,ENC_NULL,0,0,0,DIG_SHA,20,0}, {49157, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{49159,KEX_DH,SIG_DSS,ENC_RC4,1,128,128,DIG_SHA,20,0}, {49158, KEX_DH, SIG_DSS, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{49160,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0}, {49159, KEX_DH, SIG_DSS, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{49161,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49160, KEX_DH, SIG_DSS, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{49162,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA,20,0}, {49161, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49163,KEX_DH,SIG_RSA,ENC_NULL,0,0,0,DIG_SHA,20,0}, {49162, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{49164,KEX_DH,SIG_RSA,ENC_RC4,1,128,128,DIG_SHA,20,0}, {49163, KEX_DH, SIG_RSA, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{49165,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0}, {49164, KEX_DH, SIG_RSA, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{49166,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49165, KEX_DH, SIG_RSA, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{49167,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0}, {49166, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49168,KEX_DH,SIG_RSA,ENC_NULL,0,0,0,DIG_SHA,20,0}, {49167, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{49169,KEX_DH,SIG_RSA,ENC_RC4,1,128,128,DIG_SHA,20,0}, {49168, KEX_DH, SIG_RSA, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{49170,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0}, {49169, KEX_DH, SIG_RSA, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{49171,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49170, KEX_DH, SIG_RSA, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{49172,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0}, {49171, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49173,KEX_DH,SIG_NONE,ENC_NULL,0,0,0,DIG_SHA,20,0}, {49172, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{49174,KEX_DH,SIG_NONE,ENC_RC4,1,128,128,DIG_SHA,20,0}, {49173, KEX_DH, SIG_NONE, ENC_NULL, 0, 0, 0, DIG_SHA, 20, 0},
{49175,KEX_DH,SIG_NONE,ENC_3DES,8,192,192,DIG_SHA,20,0}, {49174, KEX_DH, SIG_NONE, ENC_RC4, 1, 128, 128, DIG_SHA, 20, 0},
{49176,KEX_DH,SIG_NONE,ENC_AES128,16,128,128,DIG_SHA,20,0}, {49175, KEX_DH, SIG_NONE, ENC_3DES, 8, 192, 192, DIG_SHA, 20, 0},
{49177,KEX_DH,SIG_NONE,ENC_AES256,16,256,256,DIG_SHA,20,0}, {49176, KEX_DH, SIG_NONE, ENC_AES128, 16, 128, 128, DIG_SHA, 20, 0},
{49187,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {49177, KEX_DH, SIG_NONE, ENC_AES256, 16, 256, 256, DIG_SHA, 20, 0},
{49188,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA384,48,0}, {49187, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{49189,KEX_DH,SIG_DSS,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {49188, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA384, 48, 0},
{49190,KEX_DH,SIG_DSS,ENC_AES256,16,256,256,DIG_SHA384,48,0}, {49189, KEX_DH, SIG_DSS, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{49191,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {49190, KEX_DH, SIG_DSS, ENC_AES256, 16, 256, 256, DIG_SHA384, 48, 0},
{49192,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA384,48,0}, {49191, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{49193,KEX_DH,SIG_RSA,ENC_AES128,16,128,128,DIG_SHA256,32,0}, {49192, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA384, 48, 0},
{49194,KEX_DH,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA384,48,0}, {49193, KEX_DH, SIG_RSA, ENC_AES128, 16, 128, 128, DIG_SHA256, 32, 0},
{49195,KEX_DH,SIG_DSS,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {49194, KEX_DH, SIG_RSA, ENC_AES256, 16, 256, 256, DIG_SHA384, 48, 0},
{49196,KEX_DH,SIG_DSS,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {49195, KEX_DH, SIG_DSS, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{49197,KEX_DH,SIG_DSS,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {49196, KEX_DH, SIG_DSS, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{49198,KEX_DH,SIG_DSS,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {49197, KEX_DH, SIG_DSS, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{49199,KEX_DH,SIG_RSA,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {49198, KEX_DH, SIG_DSS, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{49200,KEX_DH,SIG_RSA,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {49199, KEX_DH, SIG_RSA, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
{49201,KEX_DH,SIG_RSA,ENC_AES128_GCM,4,128,128,DIG_SHA256,32,0}, {49200, KEX_DH, SIG_RSA, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{49202,KEX_DH,SIG_RSA,ENC_AES256_GCM,4,256,256,DIG_SHA384,48,0}, {49201, KEX_DH, SIG_RSA, ENC_AES128_GCM, 4, 128, 128, DIG_SHA256, 32, 0},
// Missing: 49203-49211 {49202, KEX_DH, SIG_RSA, ENC_AES256_GCM, 4, 256, 256, DIG_SHA384, 48, 0},
{49266,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, // Missing: 49203-49211
{49267,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA256,48,0}, {49266, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{49268,KEX_DH,SIG_DSS,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {49267, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 48, 0},
{49269,KEX_DH,SIG_DSS,ENC_CAMELLIA256,16,256,256,DIG_SHA256,48,0}, {49268, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{49270,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {49269, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 48, 0},
{49271,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA256,48,0}, {49270, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{49272,KEX_DH,SIG_RSA,ENC_CAMELLIA128,16,128,128,DIG_SHA256,32,0}, {49271, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 48, 0},
{49273,KEX_DH,SIG_RSA,ENC_CAMELLIA256,16,256,256,DIG_SHA256,48,0}, {49272, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 16, 128, 128, DIG_SHA256, 32, 0},
{49274,KEX_RSA,SIG_RSA,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49273, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 16, 256, 256, DIG_SHA256, 48, 0},
{49275,KEX_RSA,SIG_RSA,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49274, KEX_RSA, SIG_RSA, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49276,KEX_DH,SIG_RSA,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49275, KEX_RSA, SIG_RSA, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49277,KEX_DH,SIG_RSA,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49276, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49278,KEX_DH,SIG_RSA,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49277, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49279,KEX_DH,SIG_RSA,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49278, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49280,KEX_DH,SIG_DSS,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49279, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49281,KEX_DH,SIG_DSS,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49280, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49282,KEX_DH,SIG_DSS,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49281, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49283,KEX_DH,SIG_DSS,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49282, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49284,KEX_DH,SIG_NONE,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49283, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49285,KEX_DH,SIG_NONE,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49284, KEX_DH, SIG_NONE, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49286,KEX_DH,SIG_DSS,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49285, KEX_DH, SIG_NONE, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49287,KEX_DH,SIG_DSS,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49286, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49288,KEX_DH,SIG_DSS,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49287, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49289,KEX_DH,SIG_DSS,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49288, KEX_DH, SIG_DSS, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49290,KEX_DH,SIG_RSA,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49289, KEX_DH, SIG_DSS, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49291,KEX_DH,SIG_RSA,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49290, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
{49292,KEX_DH,SIG_RSA,ENC_CAMELLIA128,4,128,128,DIG_SHA256,32,0}, {49291, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{49293,KEX_DH,SIG_RSA,ENC_CAMELLIA256,4,256,256,DIG_SHA384,48,0}, {49292, KEX_DH, SIG_RSA, ENC_CAMELLIA128, 4, 128, 128, DIG_SHA256, 32, 0},
// Missing: 49294-49307 {49293, KEX_DH, SIG_RSA, ENC_CAMELLIA256, 4, 256, 256, DIG_SHA384, 48, 0},
{-1} // Missing: 49294-49307
}; {-1}};
int ssl_find_cipher(num,cs) int ssl_find_cipher(int num, SSL_CipherSuite **cs) {
int num; SSL_CipherSuite *c;
SSL_CipherSuite **cs;
{
SSL_CipherSuite *c;
for(c=CipherSuites;c->number!=-1;c++){ for(c = CipherSuites; c->number != -1; c++) {
if(c->number==num){ if(c->number == num) {
*cs=c; *cs = c;
return(0); return (0);
}
} }
ERETURN(R_NOT_FOUND);
} }
ERETURN(R_NOT_FOUND);
}

4996
ssl/ssl.enums.c
View file

File diff suppressed because it is too large Load diff

1001
ssl/ssl_analyze.c
View file

File diff suppressed because it is too large Load diff

63
ssl/ssl_analyze.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ssl_analyze.h,v 1.3 2000/11/09 18:52:24 ekr Exp $ $Id: ssl_analyze.h,v 1.3 2000/11/09 18:52:24 ekr Exp $
@ -43,43 +44,42 @@
ekr@rtfm.com Tue Jan 12 08:45:44 1999 ekr@rtfm.com Tue Jan 12 08:45:44 1999
*/ */
#ifndef _ssl_analyze_h #ifndef _ssl_analyze_h
#define _ssl_analyze_h #define _ssl_analyze_h
extern proto_mod ssl_mod; extern proto_mod ssl_mod;
/*The type of data this is*/ /*The type of data this is*/
#define P_RH (1<<3) #define P_RH (1 << 3)
#define P_HT (1<<4) #define P_HT (1 << 4)
#define P_HL (1<<5) #define P_HL (1 << 5)
#define P_ND (1<<6) #define P_ND (1 << 6)
#define P_DC (1<<7) #define P_DC (1 << 7)
#define P_NR (1<<8) #define P_NR (1 << 8)
#define P_ASN (1<<9) #define P_ASN (1 << 9)
#define P_CR (1<<10) #define P_CR (1 << 10)
#define P_AD (1<<11) #define P_AD (1 << 11)
#define P_TSA (1<<12) #define P_TSA (1 << 12)
#define P_QT (1<<13) #define P_QT (1 << 13)
#define P_HO (1<<14) #define P_HO (1 << 14)
#define P_JS (1<<15) #define P_JS (1 << 15)
#define SSL_PRINT_TIMESTAMP (1) /*Timestamp records*/ #define SSL_PRINT_TIMESTAMP (1) /*Timestamp records*/
#define SSL_PRINT_HEXDUMP (1<<2) /*Print the whole record in hex*/ #define SSL_PRINT_HEXDUMP (1 << 2) /*Print the whole record in hex*/
#define SSL_PRINT_RECORD_HEADER P_RH /*Print the record header*/ #define SSL_PRINT_RECORD_HEADER P_RH /*Print the record header*/
#define SSL_PRINT_HANDSHAKE_TYPE P_HT /*Print the handshake type*/ #define SSL_PRINT_HANDSHAKE_TYPE P_HT /*Print the handshake type*/
#define SSL_PRINT_HIGHLIGHTS (P_HT | P_HL) #define SSL_PRINT_HIGHLIGHTS (P_HT | P_HL)
#define SSL_PRINT_ALL_FIELDS (P_RH | P_HT | P_HL | P_ND) #define SSL_PRINT_ALL_FIELDS (P_RH | P_HT | P_HL | P_ND)
#define SSL_PRINT_DECODE (P_DC) /*Print fields as decoded*/ #define SSL_PRINT_DECODE (P_DC) /*Print fields as decoded*/
#define SSL_PRINT_NROFF (P_NR) #define SSL_PRINT_NROFF (P_NR)
#define SSL_PRINT_DECODE_ASN1 (P_ASN) #define SSL_PRINT_DECODE_ASN1 (P_ASN)
#define SSL_PRINT_CRYPTO (P_CR) #define SSL_PRINT_CRYPTO (P_CR)
#define SSL_PRINT_APP_DATA (P_AD) #define SSL_PRINT_APP_DATA (P_AD)
#define SSL_PRINT_TIMESTAMP_ABSOLUTE (P_TSA) #define SSL_PRINT_TIMESTAMP_ABSOLUTE (P_TSA)
#define SSL_PRINT_QUIET (P_QT) #define SSL_PRINT_QUIET (P_QT)
#define SSL_PRINT_HEX_ONLY (P_HO) #define SSL_PRINT_HEX_ONLY (P_HO)
#define SSL_PRINT_JSON (P_JS) #define SSL_PRINT_JSON (P_JS)
#define SSL_PRINT_ALL 0xfffffff #define SSL_PRINT_ALL 0xfffffff
extern UINT4 SSL_print_flags; extern UINT4 SSL_print_flags;
extern char *SSL_keyfile; extern char *SSL_keyfile;
@ -87,4 +87,3 @@ extern char *SSL_password;
extern char *SSL_keylogfile; extern char *SSL_keylogfile;
#endif #endif

129
ssl/ssl_h.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ssl_h.h,v 1.6 2002/08/17 01:33:17 ekr Exp $ $Id: ssl_h.h,v 1.6 2002/08/17 01:33:17 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Fri Jan 8 14:09:37 1999 ekr@rtfm.com Fri Jan 8 14:09:37 1999
*/ */
#ifndef _ssl_h #ifndef _ssl_h
#define _ssl_h #define _ssl_h
@ -52,19 +52,18 @@
typedef struct ssl_decode_ctx_ ssl_decode_ctx; typedef struct ssl_decode_ctx_ ssl_decode_ctx;
typedef struct ssl_decoder_ ssl_decoder; typedef struct ssl_decoder_ ssl_decoder;
typedef struct d_queue_ { typedef struct d_queue_ {
short state; /*What state we're in*/ short state; /*What state we're in*/
#define SSL_READ_NONE 1 #define SSL_READ_NONE 1
#define SSL_READ_HEADER 2 #define SSL_READ_HEADER 2
int read_left; /*How many more bytes to read in this state*/ int read_left; /*How many more bytes to read in this state*/
int len; /*The length of the total record, including header*/ int len; /*The length of the total record, including header*/
UCHAR *data; /*The data for this record*/ UCHAR *data; /*The data for this record*/
UCHAR *ptr; /*The data ptr*/ UCHAR *ptr; /*The data ptr*/
int _allocated; /*The number of data bytes allocated for this record*/ int _allocated; /*The number of data bytes allocated for this record*/
segment *q; /*The segments that match this record*/ segment *q; /*The segments that match this record*/
segment *q_last; /*The last segment*/ segment *q_last; /*The last segment*/
int offset; /*How far into the first segment this record starts*/ int offset; /*How far into the first segment this record starts*/
} r_queue; } r_queue;
typedef struct ssl_extensions_ { typedef struct ssl_extensions_ {
@ -75,77 +74,75 @@ typedef struct ssl_extensions_ {
} ssl_extensions; } ssl_extensions;
typedef struct ssl_obj_ { typedef struct ssl_obj_ {
tcp_conn *conn; tcp_conn *conn;
proto_obj *logger_obj; proto_obj *logger_obj;
int r_state; int r_state;
int i_state; int i_state;
int version; int version;
UINT4 cipher_suite; UINT4 cipher_suite;
char *client_name; char *client_name;
char *client_ip; char *client_ip;
int client_port; int client_port;
char *server_name; char *server_name;
char *server_ip; char *server_ip;
int server_port; int server_port;
struct SSL_CipherSuite_ *cs; struct SSL_CipherSuite_ *cs;
r_queue *i2r_queue; r_queue *i2r_queue;
r_queue *r2i_queue; r_queue *r2i_queue;
struct timeval time_start; struct timeval time_start;
struct timeval time_last; struct timeval time_last;
ssl_decode_ctx *ssl_ctx; ssl_decode_ctx *ssl_ctx;
ssl_decoder *decoder; ssl_decoder *decoder;
ssl_extensions *extensions; ssl_extensions *extensions;
int process_ciphertext; int process_ciphertext;
/*Printing bookkeeping*/ /*Printing bookkeeping*/
#define REC_PLAINTEXT 1 #define REC_PLAINTEXT 1
#define REC_DECRYPTED_CIPHERTEXT 2 #define REC_DECRYPTED_CIPHERTEXT 2
#define REC_CIPHERTEXT 3 #define REC_CIPHERTEXT 3
int record_encryption; int record_encryption;
int direction; /* The direction we're currently working in*/ int direction; /* The direction we're currently working in*/
int record_count; int record_count;
int indent_depth; int indent_depth;
int indent_name_len; int indent_name_len;
struct json_object *cur_json_st; struct json_object *cur_json_st;
char *cur_ja3_ec_str; char *cur_ja3_ec_str;
char *cur_ja3_ecp_str; char *cur_ja3_ecp_str;
} ssl_obj; } ssl_obj;
typedef struct decoder_ { typedef struct decoder_ {
int type; int type;
char *name; char *name;
int (*print) PROTO_LIST((ssl_obj *,int direction,segment *seg,Data *data)); int(*print) PROTO_LIST((ssl_obj *, int direction, segment *seg, Data *data));
} decoder; } decoder;
#define SSL_NO_DATA 1 #define SSL_NO_DATA 1
#define SSL_BAD_CONTENT_TYPE 2 #define SSL_BAD_CONTENT_TYPE 2
#define SSL_BAD_PMS 3 #define SSL_BAD_PMS 3
#define SSL_CANT_DO_CIPHER 4 #define SSL_CANT_DO_CIPHER 4
#define SSL_NO_DECRYPT 5 #define SSL_NO_DECRYPT 5
#define SSL_BAD_MAC 6 #define SSL_BAD_MAC 6
#define SSL_BAD_DATA 7 #define SSL_BAD_DATA 7
/*SSL defines*/ /*SSL defines*/
#define COMBINE(a,b) ((a<<8) | b) #define COMBINE(a, b) ((a << 8) | b)
#define SSL_HEADER_SIZE 5 #define SSL_HEADER_SIZE 5
#define SSLV3_VERSION 0x300 #define SSLV3_VERSION 0x300
#define TLSV1_VERSION 0x301 #define TLSV1_VERSION 0x301
#define TLSV11_VERSION 0x302 #define TLSV11_VERSION 0x302
#define TLSV12_VERSION 0x303 #define TLSV12_VERSION 0x303
#define TLSV13_VERSION 0x304 #define TLSV13_VERSION 0x304
/*State defines*/ /*State defines*/
#define SSL_ST_SENT_NOTHING 0 #define SSL_ST_SENT_NOTHING 0
#define SSL_ST_HANDSHAKE 1 #define SSL_ST_HANDSHAKE 1
#define SSL_ST_SENT_CHANGE_CIPHER_SPEC 2 #define SSL_ST_SENT_CHANGE_CIPHER_SPEC 2
#include "ssldecode.h" #include "ssldecode.h"
#endif #endif

789
ssl/ssl_rec.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ssl_rec.c,v 1.3 2000/11/03 06:38:06 ekr Exp $ $Id: ssl_rec.c,v 1.3 2000/11/03 06:38:06 ekr Exp $
@ -43,8 +44,6 @@
ekr@rtfm.com Wed Aug 18 15:46:57 1999 ekr@rtfm.com Wed Aug 18 15:46:57 1999
*/ */
#include "network.h" #include "network.h"
#include "ssl_h.h" #include "ssl_h.h"
#include "sslprint.h" #include "sslprint.h"
@ -58,493 +57,453 @@
#include "ssldecode.h" #include "ssldecode.h"
#include "ssl_rec.h" #include "ssl_rec.h"
struct ssl_rec_decoder_ { struct ssl_rec_decoder_ {
SSL_CipherSuite *cs; SSL_CipherSuite *cs;
Data *mac_key; Data *mac_key;
Data *implicit_iv; /* for AEAD ciphers */ Data *implicit_iv; /* for AEAD ciphers */
Data *write_key; /* for AEAD ciphers */ Data *write_key; /* for AEAD ciphers */
#ifdef OPENSSL #ifdef OPENSSL
EVP_CIPHER_CTX *evp; EVP_CIPHER_CTX *evp;
#endif #endif
UINT8 seq; UINT8 seq;
}; };
char *digests[]={ char *digests[] = {"MD5", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", NULL};
"MD5",
"SHA1", char *ciphers[] = {
"SHA224", "DES", "3DES",
"SHA256", "RC4", "RC2",
"SHA384", "IDEA", "AES128",
"SHA512", "AES256", "CAMELLIA128",
NULL "CAMELLIA256", "SEED",
NULL, "aes-128-gcm",
"aes-256-gcm", "ChaCha20-Poly1305",
"aes-128-ccm",
"aes-128-ccm", // for ccm 8, uses the same cipher
}; };
char *ciphers[]={ static int tls_check_mac PROTO_LIST((ssl_rec_decoder * d,
"DES", int ct,
"3DES", int ver,
"RC4", UCHAR *data,
"RC2", UINT4 datalen,
"IDEA", UCHAR *iv,
"AES128", UINT4 ivlen,
"AES256", UCHAR *mac));
"CAMELLIA128", static int fmt_seq PROTO_LIST((UINT4 num, UCHAR *buf));
"CAMELLIA256",
"SEED",
NULL,
"aes-128-gcm",
"aes-256-gcm",
"ChaCha20-Poly1305",
"aes-128-ccm",
"aes-128-ccm", // for ccm 8, uses the same cipher
};
int ssl_create_rec_decoder(ssl_rec_decoder **dp,
static int tls_check_mac PROTO_LIST((ssl_rec_decoder *d,int ct, ssl_obj *ssl,
int ver,UCHAR *data,UINT4 datalen,UCHAR *iv,UINT4 ivlen,UCHAR *mac)); UCHAR *mk,
static int fmt_seq PROTO_LIST((UINT4 num,UCHAR *buf)); UCHAR *sk,
UCHAR *iv) {
int ssl_create_rec_decoder(dp,ssl,mk,sk,iv) int r, _status;
ssl_rec_decoder **dp; ssl_rec_decoder *dec = 0;
ssl_obj *ssl;
UCHAR *mk;
UCHAR *sk;
UCHAR *iv;
{
int r,_status;
ssl_rec_decoder *dec=0;
#ifdef OPENSSL #ifdef OPENSSL
const EVP_CIPHER *ciph=0; const EVP_CIPHER *ciph = 0;
int iv_len = ssl->version == TLSV13_VERSION?12:ssl->cs->block; int iv_len = ssl->version == TLSV13_VERSION ? 12 : ssl->cs->block;
/* Find the SSLeay cipher */ /* Find the SSLeay cipher */
if(ssl->cs->enc!=ENC_NULL){ if(ssl->cs->enc != ENC_NULL) {
ciph=(EVP_CIPHER *)EVP_get_cipherbyname(ciphers[ssl->cs->enc-0x30]); ciph = (EVP_CIPHER *)EVP_get_cipherbyname(ciphers[ssl->cs->enc - 0x30]);
if(!ciph) if(!ciph)
ABORT(R_INTERNAL); ABORT(R_INTERNAL);
} } else {
else { ciph = EVP_enc_null();
ciph=EVP_enc_null();
}
if(!(dec=(ssl_rec_decoder *)calloc(1,sizeof(ssl_rec_decoder))))
ABORT(R_NO_MEMORY);
dec->cs=ssl->cs;
if((r=r_data_alloc(&dec->mac_key,ssl->cs->dig_len)))
ABORT(r);
if((r=r_data_alloc(&dec->implicit_iv,iv_len)))
ABORT(r);
memcpy(dec->implicit_iv->data,iv, iv_len);
if((r=r_data_create(&dec->write_key,sk,ssl->cs->eff_bits/8)))
ABORT(r);
/*
This is necessary for AEAD ciphers, because we must wait to fully initialize the cipher
in order to include the implicit IV
*/
if(IS_AEAD_CIPHER(ssl->cs)){
sk=NULL;
iv=NULL;
}
else
memcpy(dec->mac_key->data,mk,ssl->cs->dig_len);
if(!(dec->evp=EVP_CIPHER_CTX_new()))
ABORT(R_NO_MEMORY);
EVP_CIPHER_CTX_init(dec->evp);
EVP_CipherInit(dec->evp,ciph,sk,iv,0);
#endif
*dp=dec;
_status=0;
abort:
if(_status){
ssl_destroy_rec_decoder(&dec);
}
return(_status);
} }
int ssl_destroy_rec_decoder(dp) if(!(dec = (ssl_rec_decoder *)calloc(1, sizeof(ssl_rec_decoder))))
ssl_rec_decoder **dp; ABORT(R_NO_MEMORY);
{
ssl_rec_decoder *d;
if(!dp || !*dp) dec->cs = ssl->cs;
return(0);
d=*dp;
r_data_destroy(&d->mac_key); if((r = r_data_alloc(&dec->mac_key, ssl->cs->dig_len)))
r_data_destroy(&d->implicit_iv); ABORT(r);
r_data_destroy(&d->write_key);
#ifdef OPENSSL if((r = r_data_alloc(&dec->implicit_iv, iv_len)))
if(d->evp){ ABORT(r);
EVP_CIPHER_CTX_free(d->evp); memcpy(dec->implicit_iv->data, iv, iv_len);
}
free(*dp); if((r = r_data_create(&dec->write_key, sk, ssl->cs->eff_bits / 8)))
ABORT(r);
/*
This is necessary for AEAD ciphers, because we must wait to fully
initialize the cipher in order to include the implicit IV
*/
if(IS_AEAD_CIPHER(ssl->cs)) {
sk = NULL;
iv = NULL;
} else
memcpy(dec->mac_key->data, mk, ssl->cs->dig_len);
if(!(dec->evp = EVP_CIPHER_CTX_new()))
ABORT(R_NO_MEMORY);
EVP_CIPHER_CTX_init(dec->evp);
EVP_CipherInit(dec->evp, ciph, sk, iv, 0);
#endif #endif
*dp=0; *dp = dec;
return(0); _status = 0;
abort:
if(_status) {
ssl_destroy_rec_decoder(&dec);
} }
return (_status);
#define MSB(a) ((a>>8)&0xff)
#define LSB(a) (a&0xff)
int tls13_update_rec_key(d,newkey,newiv)
ssl_rec_decoder *d;
UCHAR *newkey;
UCHAR *newiv;
{
d->write_key->data = newkey;
d->implicit_iv->data = newiv;
d->seq = 0;
} }
int tls13_decode_rec_data(ssl,d,ct,version,in,inl,out,outl) int ssl_destroy_rec_decoder(ssl_rec_decoder **dp) {
ssl_obj *ssl;
ssl_rec_decoder *d; ssl_rec_decoder *d;
int ct;
int version;
UCHAR *in;
int inl;
UCHAR *out;
int *outl;
{
int pad,i;
int r,encpadl,x,_status=0;
UCHAR aad[5],aead_nonce[12], *tag;
int taglen = d->cs->enc==ENC_AES128_CCM_8?8:16;
CRDUMP("CipherText",in,inl);
CRDUMPD("KEY",d->write_key);
CRDUMPD("IV",d->implicit_iv);
if (!IS_AEAD_CIPHER(d->cs)){
fprintf(stderr, "Non aead cipher in tls13\n");
ABORT(-1);
}
memcpy(aead_nonce, d->implicit_iv->data, 12);
for (i = 0; i < 8; i++) { // AEAD NONCE according to RFC TLS1.3
aead_nonce[12 - 1 - i] ^= ((d->seq >> (i * 8)) & 0xFF);
}
d->seq++;
CRDUMP("NONCE",aead_nonce,12);
tag = in+(inl-taglen);
CRDUMP("Tag", tag, taglen);
aad[0] = ct; if(!dp || !*dp)
aad[1] = 0x03; return (0);
aad[2] = 0x03; d = *dp;
aad[3] = MSB(inl);
aad[4] = LSB(inl);
CRDUMP("AAD",aad,5);
inl-=taglen;
if (!EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_AEAD_SET_IVLEN, 12, NULL)) { r_data_destroy(&d->mac_key);
fprintf(stderr, "Unable to set ivlen\n"); r_data_destroy(&d->implicit_iv);
ABORT(-1); r_data_destroy(&d->write_key);
} #ifdef OPENSSL
if(d->evp) {
EVP_CIPHER_CTX_free(d->evp);
}
free(*dp);
#endif
if (IS_CCM_CIPHER(d->cs) && !EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_AEAD_SET_TAG, taglen, tag)) { *dp = 0;
fprintf(stderr, "Unable to set tag for ccm cipher\n"); return (0);
ABORT(-1); }
}
if(!EVP_DecryptInit_ex(d->evp,NULL,NULL,d->write_key->data,aead_nonce)){ #define MSB(a) ((a >> 8) & 0xff)
fprintf(stderr,"Unable to init evp1\n"); #define LSB(a) (a & 0xff)
ABORT(-1);
}
if (IS_CCM_CIPHER(d->cs) && !EVP_DecryptUpdate(d->evp,NULL,outl,NULL,inl)){ int tls13_update_rec_key(ssl_rec_decoder *d, UCHAR *newkey, UCHAR *newiv) {
fprintf(stderr,"Unable to update data length\n"); d->write_key->data = newkey;
ABORT(-1); d->implicit_iv->data = newiv;
} d->seq = 0;
}
if (!EVP_DecryptUpdate(d->evp,NULL,outl,aad,5)){ int tls13_decode_rec_data(ssl_obj *ssl,
fprintf(stderr,"Unable to update aad\n"); ssl_rec_decoder *d,
ABORT(-1); int ct,
} int version,
UCHAR *in,
int inl,
UCHAR *out,
int *outl) {
int pad, i;
int r, encpadl, x, _status = 0;
UCHAR aad[5], aead_nonce[12], *tag;
int taglen = d->cs->enc == ENC_AES128_CCM_8 ? 8 : 16;
CRDUMP("CipherText", in, inl);
CRDUMPD("KEY", d->write_key);
CRDUMPD("IV", d->implicit_iv);
if(!IS_AEAD_CIPHER(d->cs)) {
fprintf(stderr, "Non aead cipher in tls13\n");
ABORT(-1);
}
memcpy(aead_nonce, d->implicit_iv->data, 12);
for(i = 0; i < 8; i++) { // AEAD NONCE according to RFC TLS1.3
aead_nonce[12 - 1 - i] ^= ((d->seq >> (i * 8)) & 0xFF);
}
d->seq++;
CRDUMP("NONCE", aead_nonce, 12);
tag = in + (inl - taglen);
CRDUMP("Tag", tag, taglen);
CRDUMP("Real CipherText", in, inl); aad[0] = ct;
if (!EVP_DecryptUpdate(d->evp,out,outl,in,inl)){ aad[1] = 0x03;
fprintf(stderr,"Unable to update with CipherText\n"); aad[2] = 0x03;
ABORT(-1); aad[3] = MSB(inl);
} aad[4] = LSB(inl);
CRDUMP("AAD", aad, 5);
inl -= taglen;
if (!IS_CCM_CIPHER(d->cs) && (!EVP_CIPHER_CTX_ctrl(d->evp,EVP_CTRL_GCM_SET_TAG,taglen,tag) || !EVP_DecryptFinal(d->evp,NULL,&x))) { if(!EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_AEAD_SET_IVLEN, 12, NULL)) {
fprintf(stderr,"BAD MAC\n"); fprintf(stderr, "Unable to set ivlen\n");
ABORT(SSL_BAD_MAC); ABORT(-1);
} }
if(IS_CCM_CIPHER(d->cs) &&
!EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_AEAD_SET_TAG, taglen, tag)) {
fprintf(stderr, "Unable to set tag for ccm cipher\n");
ABORT(-1);
}
if(!EVP_DecryptInit_ex(d->evp, NULL, NULL, d->write_key->data, aead_nonce)) {
fprintf(stderr, "Unable to init evp1\n");
ABORT(-1);
}
if(IS_CCM_CIPHER(d->cs) &&
!EVP_DecryptUpdate(d->evp, NULL, outl, NULL, inl)) {
fprintf(stderr, "Unable to update data length\n");
ABORT(-1);
}
if(!EVP_DecryptUpdate(d->evp, NULL, outl, aad, 5)) {
fprintf(stderr, "Unable to update aad\n");
ABORT(-1);
}
CRDUMP("Real CipherText", in, inl);
if(!EVP_DecryptUpdate(d->evp, out, outl, in, inl)) {
fprintf(stderr, "Unable to update with CipherText\n");
ABORT(-1);
}
if(!IS_CCM_CIPHER(d->cs) &&
(!EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_GCM_SET_TAG, taglen, tag) ||
!EVP_DecryptFinal(d->evp, NULL, &x))) {
fprintf(stderr, "BAD MAC\n");
ABORT(SSL_BAD_MAC);
}
abort: abort:
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return _status; return _status;
} }
int ssl_decode_rec_data(ssl,d,ct,version,in,inl,out,outl) int ssl_decode_rec_data(ssl_obj *ssl,
ssl_obj *ssl; ssl_rec_decoder *d,
ssl_rec_decoder *d; int ct,
int ct; int version,
int version; UCHAR *in,
UCHAR *in; int inl,
int inl; UCHAR *out,
UCHAR *out; int *outl) {
int *outl;
{
#ifdef OPENSSL #ifdef OPENSSL
int pad; int pad;
int r,encpadl,x; int r, encpadl, x;
UCHAR *mac,aead_tag[13],aead_nonce[12]; UCHAR *mac, aead_tag[13], aead_nonce[12];
CRDUMP("Ciphertext",in,inl); CRDUMP("Ciphertext", in, inl);
if(IS_AEAD_CIPHER(d->cs)){ if(IS_AEAD_CIPHER(d->cs)) {
memcpy(aead_nonce,d->implicit_iv->data,d->implicit_iv->len); memcpy(aead_nonce, d->implicit_iv->data, d->implicit_iv->len);
memcpy(aead_nonce+d->implicit_iv->len,in,12-d->implicit_iv->len); memcpy(aead_nonce + d->implicit_iv->len, in, 12 - d->implicit_iv->len);
in+=12-d->implicit_iv->len; in += 12 - d->implicit_iv->len;
inl-=12-d->implicit_iv->len; inl -= 12 - d->implicit_iv->len;
EVP_DecryptInit(d->evp, EVP_DecryptInit(d->evp, NULL, d->write_key->data, aead_nonce);
NULL,
d->write_key->data,
aead_nonce);
/*
Then tag is always 16 bytes, as per:
https://tools.ietf.org/html/rfc5116#section-5.2
*/
EVP_CIPHER_CTX_ctrl(d->evp,EVP_CTRL_GCM_SET_TAG,16,in+(inl-16));
inl-=16;
fmt_seq(d->seq,aead_tag);
d->seq++;
aead_tag[8]=ct;
aead_tag[9]=MSB(version);
aead_tag[10]=LSB(version);
aead_tag[11]=MSB(inl);
aead_tag[12]=LSB(inl);
EVP_DecryptUpdate(d->evp,NULL,outl,aead_tag,13);
EVP_DecryptUpdate(d->evp,out,outl,in,inl);
if (!(x=EVP_DecryptFinal(d->evp,NULL,&x)))
ERETURN(SSL_BAD_MAC);
}
/* /*
Encrypt-then-MAC is not used with AEAD ciphers, as per: Then tag is always 16 bytes, as per:
https://tools.ietf.org/html/rfc7366#section-3 https://tools.ietf.org/html/rfc5116#section-5.2
*/ */
else if(ssl->extensions->encrypt_then_mac==2){ EVP_CIPHER_CTX_ctrl(d->evp, EVP_CTRL_GCM_SET_TAG, 16, in + (inl - 16));
*outl=inl; inl -= 16;
/* First strip off the MAC */ fmt_seq(d->seq, aead_tag);
*outl-=d->cs->dig_len; d->seq++;
mac=in+(*outl); aead_tag[8] = ct;
aead_tag[9] = MSB(version);
aead_tag[10] = LSB(version);
aead_tag[11] = MSB(inl);
aead_tag[12] = LSB(inl);
encpadl=*outl; EVP_DecryptUpdate(d->evp, NULL, outl, aead_tag, 13);
/* Now decrypt */ EVP_DecryptUpdate(d->evp, out, outl, in, inl);
EVP_Cipher(d->evp,out,in,*outl);
CRDUMP("Plaintext",out,*outl);
/* And then strip off the padding*/ if(!(x = EVP_DecryptFinal(d->evp, NULL, &x)))
if(d->cs->block>1){ ERETURN(SSL_BAD_MAC);
pad=out[*outl-1];
*outl-=(pad+1);
}
/* TLS 1.1 and beyond: remove explicit IV, only used with
* non-stream ciphers. */
if (ssl->version>=0x0302 && ssl->cs->block > 1) {
UINT4 blk = ssl->cs->block;
if (blk <= *outl) {
*outl-=blk;
memmove(out, out+blk, *outl);
}
else {
DBG((0,"Block size greater than Plaintext!"));
ERETURN(SSL_BAD_MAC);
}
if((r=tls_check_mac(d,ct,version,in+blk,encpadl,in,blk,mac)))
ERETURN(r);
}
else
if((r=tls_check_mac(d,ct,version,in,encpadl,NULL,0,mac)))
ERETURN(r);
}
else {
/* First decrypt*/
EVP_Cipher(d->evp,out,in,inl);
CRDUMP("Plaintext",out,inl);
*outl=inl;
/* Now strip off the padding*/
if(d->cs->block>1){
pad=out[inl-1];
*outl-=(pad+1);
}
/* And the MAC */
*outl-=d->cs->dig_len;
mac=out+(*outl);
CRDUMP("Record data",out,*outl);
/* Now check the MAC */
if(ssl->version==0x300){
if((r=ssl3_check_mac(d,ct,version,out,*outl,mac)))
ERETURN(r);
}
else{
/* TLS 1.1 and beyond: remove explicit IV, only used with
* non-stream ciphers. */
if (ssl->version>=0x0302 && ssl->cs->block > 1) {
UINT4 blk = ssl->cs->block;
if (blk <= *outl) {
*outl-=blk;
memmove(out, out+blk, *outl);
}
else {
DBG((0,"Block size greater than Plaintext!"));
ERETURN(SSL_BAD_MAC);
}
}
if((r=tls_check_mac(d,ct,version,out,*outl,NULL,0,mac)))
ERETURN(r);
}
}
#endif
return(0);
} }
/*
Encrypt-then-MAC is not used with AEAD ciphers, as per:
https://tools.ietf.org/html/rfc7366#section-3
*/
else if(ssl->extensions->encrypt_then_mac == 2) {
*outl = inl;
/* First strip off the MAC */
*outl -= d->cs->dig_len;
mac = in + (*outl);
encpadl = *outl;
/* Now decrypt */
EVP_Cipher(d->evp, out, in, *outl);
CRDUMP("Plaintext", out, *outl);
/* And then strip off the padding*/
if(d->cs->block > 1) {
pad = out[*outl - 1];
*outl -= (pad + 1);
}
/* TLS 1.1 and beyond: remove explicit IV, only used with
* non-stream ciphers. */
if(ssl->version >= 0x0302 && ssl->cs->block > 1) {
UINT4 blk = ssl->cs->block;
if(blk <= *outl) {
*outl -= blk;
memmove(out, out + blk, *outl);
} else {
DBG((0, "Block size greater than Plaintext!"));
ERETURN(SSL_BAD_MAC);
}
if((r = tls_check_mac(d, ct, version, in + blk, encpadl, in, blk, mac)))
ERETURN(r);
} else if((r = tls_check_mac(d, ct, version, in, encpadl, NULL, 0, mac)))
ERETURN(r);
} else {
/* First decrypt*/
EVP_Cipher(d->evp, out, in, inl);
CRDUMP("Plaintext", out, inl);
*outl = inl;
/* Now strip off the padding*/
if(d->cs->block > 1) {
pad = out[inl - 1];
*outl -= (pad + 1);
}
/* And the MAC */
*outl -= d->cs->dig_len;
mac = out + (*outl);
CRDUMP("Record data", out, *outl);
/* Now check the MAC */
if(ssl->version == 0x300) {
if((r = ssl3_check_mac(d, ct, version, out, *outl, mac)))
ERETURN(r);
} else {
/* TLS 1.1 and beyond: remove explicit IV, only used with
* non-stream ciphers. */
if(ssl->version >= 0x0302 && ssl->cs->block > 1) {
UINT4 blk = ssl->cs->block;
if(blk <= *outl) {
*outl -= blk;
memmove(out, out + blk, *outl);
} else {
DBG((0, "Block size greater than Plaintext!"));
ERETURN(SSL_BAD_MAC);
}
}
if((r = tls_check_mac(d, ct, version, out, *outl, NULL, 0, mac)))
ERETURN(r);
}
}
#endif
return (0);
}
#ifdef OPENSSL #ifdef OPENSSL
/* This should go to 2^128, but we're never really going to see /* This should go to 2^128, but we're never really going to see
more than 2^64, so we cheat*/ more than 2^64, so we cheat*/
static int fmt_seq(num,buf) static int fmt_seq(UINT4 num, UCHAR *buf) {
UINT4 num; UINT4 netnum;
UCHAR *buf;
{
UINT4 netnum;
memset(buf,0,8); memset(buf, 0, 8);
netnum=htonl(num); netnum = htonl(num);
memcpy(buf+4,&netnum,4); memcpy(buf + 4, &netnum, 4);
return(0); return (0);
} }
static int tls_check_mac(d,ct,ver,data,datalen,iv,ivlen,mac) static int tls_check_mac(ssl_rec_decoder *d,
ssl_rec_decoder *d; int ct,
int ct; int ver,
int ver; UCHAR *data,
UCHAR *data; UINT4 datalen,
UINT4 datalen; UCHAR *iv,
UCHAR *iv; UINT4 ivlen,
UINT4 ivlen; UCHAR *mac) {
UCHAR *mac; HMAC_CTX *hm = HMAC_CTX_new();
{ if(!hm)
HMAC_CTX *hm = HMAC_CTX_new(); ERETURN(R_NO_MEMORY);
if(!hm) const EVP_MD *md;
ERETURN(R_NO_MEMORY); UINT4 l;
const EVP_MD *md; UCHAR buf[128];
UINT4 l;
UCHAR buf[128];
md=EVP_get_digestbyname(digests[d->cs->dig-0x40]); md = EVP_get_digestbyname(digests[d->cs->dig - 0x40]);
HMAC_Init_ex(hm,d->mac_key->data,d->mac_key->len,md,NULL); HMAC_Init_ex(hm, d->mac_key->data, d->mac_key->len, md, NULL);
fmt_seq(d->seq,buf); fmt_seq(d->seq, buf);
d->seq++; d->seq++;
HMAC_Update(hm,buf,8); HMAC_Update(hm, buf, 8);
buf[0]=ct; buf[0] = ct;
HMAC_Update(hm,buf,1); HMAC_Update(hm, buf, 1);
buf[0]=MSB(ver); buf[0] = MSB(ver);
buf[1]=LSB(ver); buf[1] = LSB(ver);
HMAC_Update(hm,buf,2); HMAC_Update(hm, buf, 2);
buf[0]=MSB(datalen); buf[0] = MSB(datalen);
buf[1]=LSB(datalen); buf[1] = LSB(datalen);
HMAC_Update(hm,buf,2); HMAC_Update(hm, buf, 2);
/* for encrypt-then-mac with an explicit IV */ /* for encrypt-then-mac with an explicit IV */
if(ivlen && iv){ if(ivlen && iv) {
HMAC_Update(hm,iv,ivlen); HMAC_Update(hm, iv, ivlen);
HMAC_Update(hm,data,datalen-ivlen); HMAC_Update(hm, data, datalen - ivlen);
} } else
else HMAC_Update(hm, data, datalen);
HMAC_Update(hm,data,datalen);
HMAC_Final(hm,buf,&l); HMAC_Final(hm, buf, &l);
if(memcmp(mac,buf,l)) if(memcmp(mac, buf, l))
ERETURN(SSL_BAD_MAC); ERETURN(SSL_BAD_MAC);
HMAC_CTX_free(hm); HMAC_CTX_free(hm);
return(0); return (0);
} }
int ssl3_check_mac(d,ct,ver,data,datalen,mac) int ssl3_check_mac(ssl_rec_decoder *d,
ssl_rec_decoder *d; int ct,
int ct; int ver,
int ver; UCHAR *data,
UCHAR *data; UINT4 datalen,
UINT4 datalen; UCHAR *mac) {
UCHAR *mac; EVP_MD_CTX *mc = EVP_MD_CTX_new();
{ const EVP_MD *md;
EVP_MD_CTX *mc = EVP_MD_CTX_new(); UINT4 l;
const EVP_MD *md; UCHAR buf[64], dgst[20];
UINT4 l; int pad_ct;
UCHAR buf[64],dgst[20];
int pad_ct;
pad_ct=(d->cs->dig==DIG_SHA)?40:48; pad_ct = (d->cs->dig == DIG_SHA) ? 40 : 48;
md=EVP_get_digestbyname(digests[d->cs->dig-0x40]); md = EVP_get_digestbyname(digests[d->cs->dig - 0x40]);
EVP_DigestInit(mc,md); EVP_DigestInit(mc, md);
EVP_DigestUpdate(mc,d->mac_key->data,d->mac_key->len); EVP_DigestUpdate(mc, d->mac_key->data, d->mac_key->len);
memset(buf,0x36,pad_ct); memset(buf, 0x36, pad_ct);
EVP_DigestUpdate(mc,buf,pad_ct); EVP_DigestUpdate(mc, buf, pad_ct);
fmt_seq(d->seq,buf); fmt_seq(d->seq, buf);
d->seq++; d->seq++;
EVP_DigestUpdate(mc,buf,8); EVP_DigestUpdate(mc, buf, 8);
buf[0]=ct; buf[0] = ct;
EVP_DigestUpdate(mc,buf,1); EVP_DigestUpdate(mc, buf, 1);
buf[0]=MSB(datalen); buf[0] = MSB(datalen);
buf[1]=LSB(datalen); buf[1] = LSB(datalen);
EVP_DigestUpdate(mc,buf,2); EVP_DigestUpdate(mc, buf, 2);
EVP_DigestUpdate(mc,data,datalen); EVP_DigestUpdate(mc, data, datalen);
EVP_DigestFinal(mc,dgst,&l); EVP_DigestFinal(mc, dgst, &l);
EVP_DigestInit(mc,md); EVP_DigestInit(mc, md);
EVP_DigestUpdate(mc,d->mac_key->data,d->mac_key->len); EVP_DigestUpdate(mc, d->mac_key->data, d->mac_key->len);
memset(buf,0x5c,pad_ct); memset(buf, 0x5c, pad_ct);
EVP_DigestUpdate(mc,buf,pad_ct); EVP_DigestUpdate(mc, buf, pad_ct);
EVP_DigestUpdate(mc,dgst,l); EVP_DigestUpdate(mc, dgst, l);
EVP_DigestFinal(mc,dgst,&l); EVP_DigestFinal(mc, dgst, &l);
if(memcmp(mac,dgst,l)) if(memcmp(mac, dgst, l))
ERETURN(SSL_BAD_MAC); ERETURN(SSL_BAD_MAC);
EVP_MD_CTX_free(mc); EVP_MD_CTX_free(mc);
return(0); return (0);
} }
#endif #endif

48
ssl/ssl_rec.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ssl_rec.h,v 1.2 2000/10/17 16:10:02 ekr Exp $ $Id: ssl_rec.h,v 1.2 2000/10/17 16:10:02 ekr Exp $
@ -43,24 +44,43 @@
ekr@rtfm.com Wed Aug 18 16:16:23 1999 ekr@rtfm.com Wed Aug 18 16:16:23 1999
*/ */
#ifndef _ssl_rec_h #ifndef _ssl_rec_h
#define _ssl_rec_h #define _ssl_rec_h
typedef struct ssl_rec_decoder_ ssl_rec_decoder; typedef struct ssl_rec_decoder_ ssl_rec_decoder;
int ssl_destroy_rec_decoder PROTO_LIST((ssl_rec_decoder **dp)); int ssl_destroy_rec_decoder PROTO_LIST((ssl_rec_decoder * *dp));
int ssl_create_rec_decoder PROTO_LIST((ssl_rec_decoder **dp, int ssl_create_rec_decoder PROTO_LIST(
ssl_obj *ssl,UCHAR *mk,UCHAR *sk,UCHAR *iv)); (ssl_rec_decoder * *dp, ssl_obj *ssl, UCHAR *mk, UCHAR *sk, UCHAR *iv));
int ssl_decode_rec_data PROTO_LIST((ssl_obj *ssl,ssl_rec_decoder *d, int ssl_decode_rec_data PROTO_LIST((ssl_obj * ssl,
int ct,int version,UCHAR *in,int inl,UCHAR *out,int *outl)); ssl_rec_decoder *d,
int tls13_decode_rec_data PROTO_LIST((ssl_obj *ssl,ssl_rec_decoder *d,int ct,int version,UCHAR *in,int inl,UCHAR *out,int *outl)); int ct,
int tls13_update_rec_key PROTO_LIST((ssl_rec_decoder *d,UCHAR *newkey, UCHAR *newiv)); int version,
UCHAR *in,
int inl,
UCHAR *out,
int *outl));
int tls13_decode_rec_data PROTO_LIST((ssl_obj * ssl,
ssl_rec_decoder *d,
int ct,
int version,
UCHAR *in,
int inl,
UCHAR *out,
int *outl));
int tls13_update_rec_key PROTO_LIST((ssl_rec_decoder * d,
UCHAR *newkey,
UCHAR *newiv));
int ssl3_check_mac(ssl_rec_decoder *d, int ct, int ver, UCHAR *data, int ssl3_check_mac(ssl_rec_decoder *d,
UINT4 datalen, UCHAR *mac); int ct,
int ver,
UCHAR *data,
UINT4 datalen,
UCHAR *mac);
#define IS_AEAD_CIPHER(cs) (cs->enc==0x3b||cs->enc==0x3c||cs->enc==0x3d||cs->enc==0x3e||cs->enc==0x3f) #define IS_AEAD_CIPHER(cs) \
#define IS_CCM_CIPHER(cs) (cs->enc==0x3e||cs->enc==0x3f) (cs->enc == 0x3b || cs->enc == 0x3c || cs->enc == 0x3d || cs->enc == 0x3e || \
cs->enc == 0x3f)
#define IS_CCM_CIPHER(cs) (cs->enc == 0x3e || cs->enc == 0x3f)
#endif #endif

82
ssl/sslciphers.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: sslciphers.h,v 1.3 2002/08/17 01:33:17 ekr Exp $ $Id: sslciphers.h,v 1.3 2002/08/17 01:33:17 ekr Exp $
@ -43,55 +44,52 @@
ekr@rtfm.com Tue Mar 30 18:11:55 1999 ekr@rtfm.com Tue Mar 30 18:11:55 1999
*/ */
#ifndef _sslciphers_h #ifndef _sslciphers_h
#define _sslciphers_h #define _sslciphers_h
typedef struct SSL_CipherSuite_ { typedef struct SSL_CipherSuite_ {
int number; int number;
int kex; int kex;
int sig; int sig;
int enc; int enc;
int block; int block;
int bits; int bits;
int eff_bits; int eff_bits;
int dig; int dig;
int dig_len; int dig_len;
int export; int export;
} SSL_CipherSuite; } SSL_CipherSuite;
#define KEX_RSA 0x10 #define KEX_RSA 0x10
#define KEX_DH 0x11 #define KEX_DH 0x11
#define SIG_RSA 0x20 #define SIG_RSA 0x20
#define SIG_DSS 0x21 #define SIG_DSS 0x21
#define SIG_NONE 0x22 #define SIG_NONE 0x22
#define ENC_DES 0x30 #define ENC_DES 0x30
#define ENC_3DES 0x31 #define ENC_3DES 0x31
#define ENC_RC4 0x32 #define ENC_RC4 0x32
#define ENC_RC2 0x33 #define ENC_RC2 0x33
#define ENC_IDEA 0x34 #define ENC_IDEA 0x34
#define ENC_AES128 0x35 #define ENC_AES128 0x35
#define ENC_AES256 0x36 #define ENC_AES256 0x36
#define ENC_CAMELLIA128 0x37 #define ENC_CAMELLIA128 0x37
#define ENC_CAMELLIA256 0x38 #define ENC_CAMELLIA256 0x38
#define ENC_SEED 0x39 #define ENC_SEED 0x39
#define ENC_NULL 0x3a #define ENC_NULL 0x3a
#define ENC_AES128_GCM 0x3b #define ENC_AES128_GCM 0x3b
#define ENC_AES256_GCM 0x3c #define ENC_AES256_GCM 0x3c
#define ENC_CHACHA20_POLY1305 0x3d #define ENC_CHACHA20_POLY1305 0x3d
#define ENC_AES128_CCM 0x3e #define ENC_AES128_CCM 0x3e
#define ENC_AES128_CCM_8 0x3f #define ENC_AES128_CCM_8 0x3f
#define DIG_MD5 0x40 #define DIG_MD5 0x40
#define DIG_SHA 0x41 #define DIG_SHA 0x41
#define DIG_SHA224 0x42 /* Not sure why EKR didn't follow RFC for */ #define DIG_SHA224 0x42 /* Not sure why EKR didn't follow RFC for */
#define DIG_SHA256 0x43 /* these values, but whatever, just adding on */ #define DIG_SHA256 0x43 /* these values, but whatever, just adding on */
#define DIG_SHA384 0x44 #define DIG_SHA384 0x44
#define DIG_SHA512 0x45 #define DIG_SHA512 0x45
int ssl_find_cipher PROTO_LIST((int num,SSL_CipherSuite **cs));
int ssl_find_cipher PROTO_LIST((int num, SSL_CipherSuite **cs));
#endif #endif

2344
ssl/ssldecode.c
View file

File diff suppressed because it is too large Load diff

79
ssl/ssldecode.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: ssldecode.h,v 1.3 2001/07/20 23:33:16 ekr Exp $ $Id: ssldecode.h,v 1.3 2001/07/20 23:33:16 ekr Exp $
@ -43,40 +44,56 @@
ekr@rtfm.com Thu Apr 1 15:02:02 1999 ekr@rtfm.com Thu Apr 1 15:02:02 1999
*/ */
#ifndef _ssldecode_h #ifndef _ssldecode_h
#define _ssldecode_h #define _ssldecode_h
#define CRDUMP(a,b,c) P_(P_CR) {Data d; d.data=b; d.len=c; exdump(ssl,a,&d); LF;} #define CRDUMP(a, b, c) \
#define CRDUMPD(a,b) P_(P_CR) {exdump(ssl,a,b);LF;} P_(P_CR) { \
Data d; \
d.data = b; \
d.len = c; \
exdump(ssl, a, &d); \
LF; \
}
#define CRDUMPD(a, b) \
P_(P_CR) { \
exdump(ssl, a, b); \
LF; \
}
int ssl_decode_ctx_create PROTO_LIST((ssl_decode_ctx **ctx, int ssl_decode_ctx_create PROTO_LIST(
char *keyfile,char *password,char *keylogfile)); (ssl_decode_ctx * *ctx, char *keyfile, char *password, char *keylogfile));
int ssl_decode_ctx_destroy(ssl_decode_ctx **dp); int ssl_decode_ctx_destroy(ssl_decode_ctx **dp);
int ssl_decoder_destroy PROTO_LIST((ssl_decoder **dp)); int ssl_decoder_destroy PROTO_LIST((ssl_decoder * *dp));
int ssl_decoder_create PROTO_LIST((ssl_decoder **dp,ssl_decode_ctx *ctx)); int ssl_decoder_create PROTO_LIST((ssl_decoder * *dp, ssl_decode_ctx *ctx));
int ssl_set_client_random PROTO_LIST((ssl_decoder *dp, int ssl_set_client_random PROTO_LIST((ssl_decoder * dp, UCHAR *msg, int len));
UCHAR *msg,int len)); int ssl_set_server_random PROTO_LIST((ssl_decoder * dp, UCHAR *msg, int len));
int ssl_set_server_random PROTO_LIST((ssl_decoder *dp, int ssl_set_client_session_id PROTO_LIST((ssl_decoder * dp,
UCHAR *msg,int len)); UCHAR *msg,
int ssl_set_client_session_id PROTO_LIST((ssl_decoder *dp, int len));
UCHAR *msg,int len)); int ssl_process_server_session_id
int ssl_process_server_session_id PROTO_LIST((ssl_obj *obj,ssl_decoder *dp, PROTO_LIST((ssl_obj * obj, ssl_decoder *dp, UCHAR *msg, int len));
UCHAR *msg,int len)); int ssl_process_client_session_id
int ssl_process_client_session_id PROTO_LIST((ssl_obj *obj,ssl_decoder *dp, PROTO_LIST((ssl_obj * obj, ssl_decoder *dp, UCHAR *msg, int len));
UCHAR *msg,int len)); int ssl_process_client_key_exchange
int ssl_process_client_key_exchange PROTO_LIST((struct ssl_obj_ *, PROTO_LIST((struct ssl_obj_ *, ssl_decoder *d, UCHAR *msg, int len));
ssl_decoder *d,UCHAR *msg,int len)); int ssl_process_change_cipher_spec PROTO_LIST((ssl_obj * ssl,
int ssl_process_change_cipher_spec PROTO_LIST((ssl_obj *ssl, ssl_decoder *d,
ssl_decoder *d,int direction)); int direction));
int ssl_update_handshake_messages PROTO_LIST((ssl_obj *ssl, int ssl_update_handshake_messages PROTO_LIST((ssl_obj * ssl, Data *data));
Data *data)); int ssl_decode_record PROTO_LIST((ssl_obj * ssl,
int ssl_decode_record PROTO_LIST((ssl_obj *ssl,ssl_decoder *dec,int direction, ssl_decoder *dec,
int ct,int version,Data *d)); int direction,
int ssl_tls13_generate_keying_material PROTO_LIST((ssl_obj *obj,ssl_decoder *dec)); int ct,
int ssl_process_handshake_finished PROTO_LIST((ssl_obj* ssl,ssl_decoder *dec, Data *data)); int version,
int ssl_tls13_update_keying_material PROTO_LIST((ssl_obj *ssl,ssl_decoder *dec,int dir)); Data *d));
int ssl_tls13_generate_keying_material PROTO_LIST((ssl_obj * obj,
ssl_decoder *dec));
int ssl_process_handshake_finished PROTO_LIST((ssl_obj * ssl,
ssl_decoder *dec,
Data *data));
int ssl_tls13_update_keying_material PROTO_LIST((ssl_obj * ssl,
ssl_decoder *dec,
int dir));
#endif #endif

1271
ssl/sslprint.c
View file

File diff suppressed because it is too large Load diff

141
ssl/sslprint.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: sslprint.h,v 1.3 2000/11/03 06:38:06 ekr Exp $ $Id: sslprint.h,v 1.3 2000/11/03 06:38:06 ekr Exp $
@ -43,66 +44,104 @@
ekr@rtfm.com Wed Feb 10 15:34:14 1999 ekr@rtfm.com Wed Feb 10 15:34:14 1999
*/ */
#ifndef _sslprint_h #ifndef _sslprint_h
#define _sslprint_h #define _sslprint_h
#include "ssl_analyze.h" #include "ssl_analyze.h"
#include "ssl_h.h" #include "ssl_h.h"
int ssl_expand_record PROTO_LIST((ssl_obj *ssl, int ssl_expand_record PROTO_LIST(
segment *q,int direction,UCHAR *data,int len)); (ssl_obj * ssl, segment *q, int direction, UCHAR *data, int len));
int ssl_decode_switch PROTO_LIST((ssl_obj *ssl, int ssl_decode_switch PROTO_LIST((ssl_obj * ssl,
decoder *dtable,int value,int dir,segment *seg,Data *data)); decoder *dtable,
int ssl_decode_uintX PROTO_LIST((ssl_obj *ssl,char *name,int size, int value,
UINT4 print,Data *data,UINT4 *x)); int dir,
int ssl_decode_opaque_array PROTO_LIST((ssl_obj *ssl,char *name,int size, segment *seg,
UINT4 print,Data *data,Data *x)); Data *data));
int ssl_decode_enum PROTO_LIST((ssl_obj *ssl,char *name, int ssl_decode_uintX PROTO_LIST(
int size,decoder *decode,UINT4 p,Data *data, (ssl_obj * ssl, char *name, int size, UINT4 print, Data *data, UINT4 *x));
UINT4 *x)); int ssl_decode_opaque_array PROTO_LIST(
int ssl_lookup_enum PROTO_LIST((ssl_obj *ssl,decoder *dtable, (ssl_obj * ssl, char *name, int size, UINT4 print, Data *data, Data *x));
UINT4 val,char **ptr)); int ssl_decode_enum PROTO_LIST((ssl_obj * ssl,
int ssl_print_enum PROTO_LIST((ssl_obj *obj,char *name, char *name,
decoder *decode,UINT4 value)); int size,
int ssl_get_enum_str PROTO_LIST((ssl_obj *obj,char *outstr, decoder *decode,
decoder *decode,UINT4 value)); UINT4 p,
int print_data PROTO_LIST((ssl_obj *ssl,Data *d)); Data *data,
int process_v2_hello PROTO_LIST((ssl_obj *ssl,segment *seg)); UINT4 *x));
int process_beginning_plaintext PROTO_LIST((ssl_obj *ssl, int ssl_lookup_enum
segment *seg,int direction)); PROTO_LIST((ssl_obj * ssl, decoder *dtable, UINT4 val, char **ptr));
int ssl_print_direction_indicator PROTO_LIST((ssl_obj *ssl,int dir)); int ssl_print_enum
int ssl_print_timestamp PROTO_LIST((ssl_obj *ssl,struct timeval *ts)); PROTO_LIST((ssl_obj * obj, char *name, decoder *decode, UINT4 value));
int ssl_print_record_num PROTO_LIST((ssl_obj *ssl)); int ssl_get_enum_str
int ssl_print_cipher_suite PROTO_LIST((ssl_obj *ssl,int version,int p, PROTO_LIST((ssl_obj * obj, char *outstr, decoder *decode, UINT4 value));
UINT4 val)); int print_data PROTO_LIST((ssl_obj * ssl, Data *d));
int process_v2_hello PROTO_LIST((ssl_obj * ssl, segment *seg));
int process_beginning_plaintext PROTO_LIST((ssl_obj * ssl,
segment *seg,
int direction));
int ssl_print_direction_indicator PROTO_LIST((ssl_obj * ssl, int dir));
int ssl_print_timestamp PROTO_LIST((ssl_obj * ssl, struct timeval *ts));
int ssl_print_record_num PROTO_LIST((ssl_obj * ssl));
int ssl_print_cipher_suite
PROTO_LIST((ssl_obj * ssl, int version, int p, UINT4 val));
int explain PROTO_LIST((ssl_obj *ssl,char *format,...)); int explain PROTO_LIST((ssl_obj * ssl, char *format, ...));
int exdump PROTO_LIST((ssl_obj *ssl,char *name,Data *data)); int exdump PROTO_LIST((ssl_obj * ssl, char *name, Data *data));
int exstr PROTO_LIST((ssl_obj *ssl,char *name,Data *data)); int exstr PROTO_LIST((ssl_obj * ssl, char *name, Data *data));
#define SSL_DECODE_UINT8(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 1, b, c, d))) \
ERETURN(r)
#define SSL_DECODE_UINT16(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 2, b, c, d))) \
ERETURN(r)
#define SSL_DECODE_UINT24(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 3, b, c, d))) \
ERETURN(r)
#define SSL_DECODE_UINT32(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 4, b, c, d))) \
ERETURN(r)
#define SSL_DECODE_OPAQUE_ARRAY(a, n, b, c, d, e) \
if((r = ssl_decode_opaque_array(a, n, b, c, d, e))) \
ERETURN(r)
#define SSL_DECODE_ENUM(a, b, c, d, e, f, g) \
if((r = ssl_decode_enum(a, b, c, d, e, f, g))) \
ERETURN(r)
#define SSL_DECODE_UINT8_ABORT(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 1, b, c, d))) \
ABORT(r)
#define SSL_DECODE_UINT16_ABORT(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 2, b, c, d))) \
ABORT(r)
#define SSL_DECODE_UINT24_ABORT(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 3, b, c, d))) \
ABORT(r)
#define SSL_DECODE_UINT32_ABORT(a, n, b, c, d) \
if((r = ssl_decode_uintX(a, n, 4, b, c, d))) \
ABORT(r)
#define SSL_DECODE_OPAQUE_ARRAY_ABORT(a, n, b, c, d, e) \
if((r = ssl_decode_opaque_array(a, n, b, c, d, e))) \
ABORT(r)
#define SSL_DECODE_ENUM_ABORT(a, b, c, d, e, f, g) \
if((r = ssl_decode_enum(a, b, c, d, e, f, g))) \
ABORT(r)
#define P_(p) if((p == SSL_PRINT_ALL) || (p & SSL_print_flags))
#define SSL_DECODE_UINT8(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,1,b,c,d))) ERETURN(r) #define INDENT \
#define SSL_DECODE_UINT16(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,2,b,c,d))) ERETURN(r) if(!(NET_print_flags & NET_PRINT_JSON)) \
#define SSL_DECODE_UINT24(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,3,b,c,d))) ERETURN(r) do { \
#define SSL_DECODE_UINT32(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,4,b,c,d))) ERETURN(r) int i; \
#define SSL_DECODE_OPAQUE_ARRAY(a,n,b,c,d,e) if((r=ssl_decode_opaque_array(a,n,b,c,d,e))) ERETURN(r) for(i = 0; i < (ssl->indent_depth + ssl->indent_name_len); i++) \
#define SSL_DECODE_ENUM(a,b,c,d,e,f,g) if((r=ssl_decode_enum(a,b,c,d,e,f,g))) ERETURN(r) printf("%s", SSL_print_flags &SSL_PRINT_NROFF ? " " : " "); \
#define SSL_DECODE_UINT8_ABORT(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,1,b,c,d))) ABORT(r) } while(0)
#define SSL_DECODE_UINT16_ABORT(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,2,b,c,d))) ABORT(r) #define INDENT_INCR ssl->indent_depth += 2
#define SSL_DECODE_UINT24_ABORT(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,3,b,c,d))) ABORT(r) #define INDENT_POP ssl->indent_depth -= 2
#define SSL_DECODE_UINT32_ABORT(a,n,b,c,d) if((r=ssl_decode_uintX(a,n,4,b,c,d))) ABORT(r)
#define SSL_DECODE_OPAQUE_ARRAY_ABORT(a,n,b,c,d,e) if((r=ssl_decode_opaque_array(a,n,b,c,d,e))) ABORT(r)
#define SSL_DECODE_ENUM_ABORT(a,b,c,d,e,f,g) if((r=ssl_decode_enum(a,b,c,d,e,f,g))) ABORT(r)
#define P_(p) if((p==SSL_PRINT_ALL) || (p & SSL_print_flags))
#define INDENT if(!(NET_print_flags & NET_PRINT_JSON)) do {int i; for(i=0;i<(ssl->indent_depth + ssl->indent_name_len);i++) printf("%s",SSL_print_flags & SSL_PRINT_NROFF?" ":" ");} while(0)
#define INDENT_INCR ssl->indent_depth+=2
#define INDENT_POP ssl->indent_depth-=2
#define INDENT_NAME(x) ssl->indent_name_len += strlen(x) #define INDENT_NAME(x) ssl->indent_name_len += strlen(x)
#define INDENT_NAME_POP ssl->indent_name_len=0 #define INDENT_NAME_POP ssl->indent_name_len = 0
#define LINE_LEFT (80-(ssl->indent_name_len + ssl->indent_depth) #define LINE_LEFT (80-(ssl->indent_name_len + ssl->indent_depth)
#define LF if(!(NET_print_flags & NET_PRINT_JSON)) printf("\n") #define LF \
if(!(NET_print_flags & NET_PRINT_JSON)) \
printf("\n")
#endif #endif

324
ssl/sslxprint.c
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: sslxprint.c,v 1.3 2000/11/03 06:38:06 ekr Exp $ $Id: sslxprint.c,v 1.3 2000/11/03 06:38:06 ekr Exp $
@ -43,7 +44,6 @@
ekr@rtfm.com Thu Mar 25 21:17:16 1999 ekr@rtfm.com Thu Mar 25 21:17:16 1999
*/ */
#include <json.h> #include <json.h>
#include "network.h" #include "network.h"
#include "ssl_h.h" #include "ssl_h.h"
@ -57,207 +57,195 @@
#define BUFSIZE 1024 #define BUFSIZE 1024
static int sslx__print_dn PROTO_LIST((ssl_obj *ssl,char *x)); static int sslx__print_dn PROTO_LIST((ssl_obj * ssl, char *x));
#ifdef OPENSSL #ifdef OPENSSL
static int sslx__print_serial PROTO_LIST((ssl_obj *ssl,ASN1_INTEGER *a)); static int sslx__print_serial PROTO_LIST((ssl_obj * ssl, ASN1_INTEGER *a));
#endif #endif
int sslx_print_certificate(ssl,data,pf) int sslx_print_certificate(ssl_obj *ssl, Data *data, int pf) {
ssl_obj *ssl;
Data *data;
int pf;
{
#ifdef OPENSSL #ifdef OPENSSL
X509 *x=0; X509 *x = 0;
ASN1_INTEGER *a; ASN1_INTEGER *a;
#endif #endif
UCHAR *d; UCHAR *d;
int _status; int _status;
struct json_object *cert_obj; struct json_object *cert_obj;
#ifdef OPENSSL #ifdef OPENSSL
P_(P_ASN){ P_(P_ASN) {
char buf[BUFSIZE]; char buf[BUFSIZE];
int ext; int ext;
char *b64_cert; char *b64_cert;
char *serial_str = NULL; char *serial_str = NULL;
Data data_tmp; Data data_tmp;
struct json_object *jobj; struct json_object *jobj;
jobj = ssl->cur_json_st; jobj = ssl->cur_json_st;
cert_obj = json_object_new_object(); cert_obj = json_object_new_object();
d=data->data; d = data->data;
if(!(b64_cert=(char *)calloc(1,sizeof(char) * ((((data->len) + 3 - 1)/3) * 4 + 1)))) if(!(b64_cert = (char *)calloc(
ABORT(R_NO_MEMORY); 1, sizeof(char) * ((((data->len) + 3 - 1) / 3) * 4 + 1))))
ABORT(R_NO_MEMORY);
EVP_EncodeBlock((unsigned char *)b64_cert, d, data->len); EVP_EncodeBlock((unsigned char *)b64_cert, d, data->len);
json_object_object_add(cert_obj, "cert_der", json_object_new_string(b64_cert)); json_object_object_add(cert_obj, "cert_der",
free(b64_cert); json_object_new_string(b64_cert));
free(b64_cert);
if(!(x=d2i_X509(0,(const unsigned char **) &d,data->len))){ if(!(x = d2i_X509(0, (const unsigned char **)&d, data->len))) {
explain(ssl,"Bad certificate"); explain(ssl, "Bad certificate");
ABORT(R_BAD_DATA); ABORT(R_BAD_DATA);
}
X509_NAME_oneline(X509_get_subject_name(x),buf,
BUFSIZE);
explain(ssl,"Subject\n");
INDENT_INCR;
json_object_object_add(cert_obj, "cert_subject", json_object_new_string(buf));
sslx__print_dn(ssl,buf);
INDENT_POP;
X509_NAME_oneline(X509_get_issuer_name(x),buf,
BUFSIZE);
explain(ssl,"Issuer\n");
INDENT_INCR;
json_object_object_add(cert_obj, "cert_issuer", json_object_new_string(buf));
sslx__print_dn(ssl,buf);
INDENT_POP;
a=X509_get_serialNumber(x);
explain(ssl,"Serial ");
if(!(serial_str=(char *)calloc(1,sizeof(char) * (a->length * 3))))
ABORT(R_NO_MEMORY);
INIT_DATA(data_tmp,a->data,a->length);
exstr(ssl, serial_str, &data_tmp);
json_object_object_add(cert_obj, "cert_serial", json_object_new_string(serial_str));
free(serial_str);
sslx__print_serial(ssl,a);
ext=X509_get_ext_count(x);
if(ext>0){
int i,j;
UCHAR buf[1024];
explain(ssl,"Extensions\n");
INDENT_INCR;
for(i=0;i<ext;i++){
X509_EXTENSION *ex;
ASN1_OBJECT *obj;
ex=X509_get_ext(x,i);
obj=X509_EXTENSION_get_object(ex);
i2t_ASN1_OBJECT((char *)buf,sizeof(buf),obj);
explain(ssl,"Extension: %s\n",buf);
j=X509_EXTENSION_get_critical(ex);
if(j){
INDENT;
explain(ssl,"Critical\n");
}
if(SSL_print_flags & SSL_PRINT_NROFF){
if(ssl->process_ciphertext&ssl->direction)
printf("\\f(CI");
else
printf("\\fC");
INDENT_INCR;
INDENT;
if(!X509V3_EXT_print_fp(stdout,ex,0,0)){
printf("Hex value");
}
INDENT_POP;
explain(ssl,"\n");
}
}
INDENT_POP;
}
else{
#endif
P_(pf){
exdump(ssl,"certificate",data);
}
#ifdef OPENSSL
}
struct json_object *certs_array;
json_object_object_get_ex(jobj, "cert_chain", &certs_array);
json_object_array_add(certs_array,cert_obj);
} }
#endif X509_NAME_oneline(X509_get_subject_name(x), buf, BUFSIZE);
explain(ssl, "Subject\n");
INDENT_INCR;
json_object_object_add(cert_obj, "cert_subject",
json_object_new_string(buf));
sslx__print_dn(ssl, buf);
INDENT_POP;
X509_NAME_oneline(X509_get_issuer_name(x), buf, BUFSIZE);
explain(ssl, "Issuer\n");
INDENT_INCR;
json_object_object_add(cert_obj, "cert_issuer",
json_object_new_string(buf));
sslx__print_dn(ssl, buf);
INDENT_POP;
a = X509_get_serialNumber(x);
explain(ssl, "Serial ");
if(!(serial_str = (char *)calloc(1, sizeof(char) * (a->length * 3))))
ABORT(R_NO_MEMORY);
INIT_DATA(data_tmp, a->data, a->length);
exstr(ssl, serial_str, &data_tmp);
json_object_object_add(cert_obj, "cert_serial",
json_object_new_string(serial_str));
free(serial_str);
sslx__print_serial(ssl, a);
_status=0; ext = X509_get_ext_count(x);
abort: if(ext > 0) {
#ifdef OPENSSL int i, j;
if(x) X509_free(x); UCHAR buf[1024];
explain(ssl, "Extensions\n");
INDENT_INCR;
for(i = 0; i < ext; i++) {
X509_EXTENSION *ex;
ASN1_OBJECT *obj;
ex = X509_get_ext(x, i);
obj = X509_EXTENSION_get_object(ex);
i2t_ASN1_OBJECT((char *)buf, sizeof(buf), obj);
explain(ssl, "Extension: %s\n", buf);
j = X509_EXTENSION_get_critical(ex);
if(j) {
INDENT;
explain(ssl, "Critical\n");
}
if(SSL_print_flags & SSL_PRINT_NROFF) {
if(ssl->process_ciphertext & ssl->direction)
printf("\\f(CI");
else
printf("\\fC");
INDENT_INCR;
INDENT;
if(!X509V3_EXT_print_fp(stdout, ex, 0, 0)) {
printf("Hex value");
}
INDENT_POP;
explain(ssl, "\n");
}
}
INDENT_POP;
} else {
#endif #endif
if(_status && cert_obj) json_object_put(cert_obj); P_(pf) { exdump(ssl, "certificate", data); }
return(_status); #ifdef OPENSSL
}
struct json_object *certs_array;
json_object_object_get_ex(jobj, "cert_chain", &certs_array);
json_object_array_add(certs_array, cert_obj);
} }
int sslx_print_dn(ssl,data,pf)
ssl_obj *ssl;
Data *data;
int pf;
{
UCHAR buf[BUFSIZE];
int _status;
UCHAR *d=data->data;
#ifdef OPENSSL
X509_NAME *n=0;
#endif #endif
P_(pf){ _status = 0;
abort:
#ifdef OPENSSL #ifdef OPENSSL
P_(P_ASN){ if(x)
if(!(n=d2i_X509_NAME(0,(const unsigned char **) &d,data->len))) X509_free(x);
ABORT(R_BAD_DATA);
X509_NAME_oneline(n,(char *)buf,BUFSIZE);
sslx__print_dn(ssl,(char *)buf);
}
else{
#endif #endif
exdump(ssl,0,data); if(_status && cert_obj)
#ifdef OPENSSL json_object_put(cert_obj);
} return (_status);
#endif }
}
_status=0; int sslx_print_dn(ssl_obj *ssl, Data *data, int pf) {
abort: UCHAR buf[BUFSIZE];
int _status;
UCHAR *d = data->data;
#ifdef OPENSSL
X509_NAME *n = 0;
#endif
P_(pf){
#ifdef OPENSSL
P_(P_ASN){if(!(n = d2i_X509_NAME(0, (const unsigned char **)&d,
data->len))) ABORT(R_BAD_DATA);
X509_NAME_oneline(n, (char *)buf, BUFSIZE);
sslx__print_dn(ssl, (char *)buf);
}
else {
#endif
exdump(ssl, 0, data);
#ifdef OPENSSL
}
#endif
}
_status = 0;
abort :
#ifdef OPENSSL #ifdef OPENSSL
if(n) X509_NAME_free(n); if(n) X509_NAME_free(n);
#endif #endif
return(_status); return (_status);
} }
static int sslx__print_dn(ssl,x) static int sslx__print_dn(ssl_obj *ssl, char *x) {
ssl_obj *ssl; char *slash;
char *x;
{
char *slash;
if(*x=='/') x++; if(*x == '/')
x++;
while (x){ while(x) {
if((slash=strchr(x,'/'))){ if((slash = strchr(x, '/'))) {
*slash=0; *slash = 0;
} }
explain(ssl,"%s\n",x); explain(ssl, "%s\n", x);
x=slash?slash+1:0; x = slash ? slash + 1 : 0;
}; };
return(0); return (0);
} }
#ifdef OPENSSL #ifdef OPENSSL
static int sslx__print_serial(ssl,a) static int sslx__print_serial(ssl_obj *ssl, ASN1_INTEGER *a) {
ssl_obj *ssl; Data d;
ASN1_INTEGER *a;
{
Data d;
if(a->length==0) if(a->length == 0)
printf("0"); printf("0");
INIT_DATA(d,a->data,a->length); INIT_DATA(d, a->data, a->length);
exdump(ssl,0,&d); exdump(ssl, 0, &d);
return(0); return (0);
} }
#endif #endif

9
ssl/sslxprint.h
View file

@ -35,7 +35,8 @@
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH DAMAGE. OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY SUCH
DAMAGE.
$Id: sslxprint.h,v 1.2 2000/10/17 16:10:02 ekr Exp $ $Id: sslxprint.h,v 1.2 2000/10/17 16:10:02 ekr Exp $
@ -43,12 +44,10 @@
ekr@rtfm.com Thu Mar 25 21:23:34 1999 ekr@rtfm.com Thu Mar 25 21:23:34 1999
*/ */
#ifndef _sslxprint_h #ifndef _sslxprint_h
#define _sslxprint_h #define _sslxprint_h
int sslx_print_certificate PROTO_LIST((ssl_obj *ssl,Data *data,int pf)); int sslx_print_certificate PROTO_LIST((ssl_obj * ssl, Data *data, int pf));
int sslx_print_dn PROTO_LIST((ssl_obj *ssl,Data *data,int pf)); int sslx_print_dn PROTO_LIST((ssl_obj * ssl, Data *data, int pf));
#endif #endif