home *** CD-ROM | disk | FTP | other *** search
/ Hackers Handbook - Millenium Edition / Hackers Handbook.iso / library / hack99 / defunct.txt < prev    next >
Encoding:
Text File  |  1999-03-24  |  8.5 KB  |  233 lines
  1.  *=-###############################################-=*
  2.      [*]                                               [*]
  3.       |             Defunct Internet Protocol  [DIP]    |
  4.       |                   optiklenz                     |
  5.       |             Legions Of the Underground          |
  6.       +---+*LoU*********************************LoU*+---+
  7.  
  8.  
  9. *****************************************************************
  10. The first few paragraphs of this text serve as an general outlook 
  11. for people who have no prior knowledge of the tcp/ip protocols
  12.  
  13. -----------------------------------------------------------------
  14.  
  15. Every host or computer on the internet is addressed  by an IP number. 
  16. No two IP numbers are equivalent. A perfect analogy would be the
  17. procedure of the postal service.  Think of IP's as being houses
  18. each house needs an individual identifier that is contrary 
  19. to the other.
  20.  
  21.   [90150^] - House 1   [90151^] - House 2    [90153^] - House 3
  22.  
  23. Each house has a different home address so that the post office
  24. Is able to find it and deliver mail accordingly.  This goes alike 
  25. for an IP number.  Each IP number is divergent from the other 
  26. which allows for data intended for a particular host to be 
  27. transferred to it's  destination with out error.
  28.  
  29.   The ip's network ID remains the same in all occurrences , but it's 
  30.   host ID changes.
  31.  
  32.     Example:    60.0.0.0 - Where 60 is the network ID
  33.  
  34.  
  35. All IP addresses are 32bits long, and are comprised of four 8bit segments
  36. known as octets The way this is addressed is using 
  37. ones, and zeros. The human mind doesn't designate  numbers 
  38. as well as it does words this is the reason for domain naming. 
  39. Could you imagine if people were identified by a numeric value
  40. rather than a name?  It'd be pretty ridiculous.  Picture yourself 
  41. calling out to a friend "Hey 19682842434 ?"  so for 
  42. the same convenience of having a static name we have static IP's
  43. with a logical address (127.0.0.1) or a  domain name
  44. (www.localhost.com) that interprets all the data for us.
  45.  
  46.  
  47. Quick overview on Process of IP Conversion.
  48.  
  49.  
  50.                  
  51. <*-------------------------------------*>
  52. 10000001 01100100 00001111 00000110 - IP 
  53. <*-------------------------------------*> 
  54.                  to
  55. <*-------------------------------------*>
  56. 129.100.15.6 <-- decimal conversion
  57. <*-------------------------------------*>
  58.                  to
  59. <*-------------------------------------*>
  60. PC <-- Host Name
  61. <*-------------------------------------*>
  62.  
  63. Protocols convert to the physical address going from PC
  64. (Host Name) to 129.100.15.6 (decimal address).
  65.  
  66. +-=============-+
  67. * The Process   *
  68. +-=============-+
  69.  
  70.  
  71.  
  72. Seeing that IP's are 32 bits in 4 8bit segments.
  73. If  you take 32 (bits of the ip) and multiply it
  74. by 8(bits of each ip segment) you get 256 bits or 
  75. a cluster of 1's, and 0's depending on how you are 
  76. looking at it. =]  
  77.  
  78. The give an example of how we go from an IP in decimal form 
  79. to a defunct ip. We'll use www.legions.org.
  80. Resolve the domain name. In this case we have 199.227.88.145:
  81.  
  82. [segments referred to as SEG]
  83.   ********************
  84.   256| 3-2-1 method...
  85.   ********************
  86.    32(8) = 256
  87.       |_SEG1(199)*256^3     
  88.                    |
  89.      SEG2(227)*256^2_+
  90.                    | 
  91.         SEG3(88)*256_+          
  92.                    | 
  93.            SEG4(145)_+    
  94.                    |
  95.                  145_+ -= 3353565329 (new identifier)
  96.  
  97.     Defunct IP: The reason I call the new identifier a defunct IP
  98.                 is because when it goes through the above process it is
  99.                 no longer decimal form. So I refer to 
  100.                 it as a "dead ip"
  101.    
  102.  
  103.    Security Analysis:
  104.    
  105.        If you take an IP in decimal form, and convert it to  a defunct IP [DIP] 
  106.    services will still resolve the number as an identifier for that host
  107.    but since it no longer has any decimals separating segments it is perceived
  108.    as an Intranet host rather than its original standing as an IP.  This 
  109.    brings some questions of security since Intranets tend to 
  110.    have very little security implementation.
  111.  
  112.    Since the given locator is no longer considered an IP it is no longer
  113.    conditional to the same security restrictions imposed on a practical
  114.    host identifier.  For this reason If you were obstructed from accessing
  115.    specific things from behind a proxy, using the new 
  116.    identifier the security measures otherwise implemented no longer apply.
  117.    
  118.       open: www.legions.org
  119.       no connection do to proxy restrictions
  120.  
  121.   meaning:  where as 199.227.88.145 would obtain no connection
  122.             3353565329 would process.
  123.             
  124.  
  125.     Also if you are being blocked from certain sites because they 
  126.     might contain ActiveX, Java applets, or if you just use AOL whereby
  127.     90% of the internet is blocked out anyway the defunct ip method will 
  128.     allow you to view the site with out any complications.
  129.      
  130.     The reason some administrators block sites that contain java, and 
  131.     Active X is because scripts on certain sites may be a security hazard
  132.     or malicious in the sense that they cause a DOS (denial of service)
  133.     or do other things which would cause otherwise keep the system from 
  134.     executing what it's setup to do.
  135.     
  136.  
  137.  
  138. --------------------------------------------------------
  139. The code below was written to go with this article
  140. -------------------------------------------------------
  141.  
  142. /*
  143. * defunct.cpp - use: Enter logical IP number. Results: Defunct Address
  144. * Defunct IP Calculation Module-
  145. * Legions Of the Underground - http://www.legions.org
  146. * Code written to assist article
  147. * written on Defunct IP's, and Security Risk in Keen Veracity 6
  148. * optiklenz@legions.org -  optiklenz
  149. * This code may be alter'd as long as proper credit is givin
  150. */
  151.  
  152.  
  153. #include <iostream.h>
  154. #include <stdio.h>
  155. #include <stdlib.h>
  156.  
  157. int ClearCin(istream& isIn)    // Clears istream object
  158. {
  159.         streambuf*  sbpThis;
  160.          char        szTempBuf[20];
  161.         int         nCount, nRet = isIn.rdstate();
  162.          {
  163.           isIn.clear();                 // Clear error flags
  164.           sbpThis = isIn.rdbuf();       // Get streambuf pointer
  165.           nCount = sbpThis->in_avail(); // Number of characters in buffer
  166.           while (nCount)                // Extract them to szTempBuf
  167.                                                 {
  168.                         if  (nCount > 20)
  169.                                                                   {
  170.                sbpThis->sgetn(szTempBuf, 20);
  171.                nCount -= 20;
  172.                    }
  173.                                                            else
  174.                                                                  {
  175.                                  sbpThis->sgetn(szTempBuf, nCount);
  176.                                           nCount = 0;
  177.                                                                   }
  178.                                                 }
  179.                   }
  180.          return  nRet;
  181. }
  182.  
  183.  
  184.  
  185. int main()
  186. {
  187.                   double result=0;
  188.                   double numb[4];
  189.                 char text[15];
  190.                 cout << "Input the address you wish to use/modify...\n> ";
  191.                   cin.getline (text, 16);
  192.                   ClearCin(cin);
  193.                   //Parse numbers
  194.                   for (int x = 0, y = 0; !(x>3); x++)
  195.                   {
  196.                           char stay[3];
  197.                           if (x!=3)
  198.                           {
  199.                           for(int z =0;text[y]!='.';y++,z++)
  200.                           {
  201.                                              stay[z] = text[y];
  202.                           }
  203.                           numb[x] = atof(stay);
  204.                           }
  205.                           else
  206.                           {
  207.                           for(int z =0;text[y]!='\0';y++,z++)
  208.                           {
  209.                                    stay[z] = text[y];
  210.                           }
  211.                                          numb[x] = atof(stay);
  212.                                          }
  213.                                          if (x!=3)
  214.                                                                 y++;
  215.                                          stay[0] = '\0';
  216.                                          stay[1] = '\0';
  217.                                          stay[2] = '\0';
  218.                   }
  219.     cout << numb[0] << " " << numb[1] << " " << numb[2] << " " << numb[3];
  220.                   //run algorithim
  221.                   result = ((numb[0])*(16777216));
  222.                   result += ((numb[1])*(65536));
  223.                   result += ((numb[2])*(256));
  224.                   result += (numb[3]);
  225.                   int dec=0, sign=0;
  226.                   cout << endl << ecvt(result, 10, &dec, &sign) << flush;
  227.  
  228.                   return 0;
  229. }
  230.  
  231.  
  232.  
  233.