home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / c / cops_104.zip / cops_104 / src / crack-lib.c < prev    next >
C/C++ Source or Header  |  1992-03-10  |  8KB  |  437 lines
  1. /*
  2.  * This program is copyright Alec Muffett 1991 except for some portions of
  3.  * code in "crack-fcrypt.c" which are copyright Robert Baldwin, Icarus
  4.  * Sparry and Alec Muffett.  The author(s) disclaims all responsibility or
  5.  * liability with respect to it's usage or its effect upon hardware or
  6.  * computer systems, and maintain copyright as set out in the "LICENCE"
  7.  * document which accompanies distributions of Crack v4.0 and upwards. 
  8.  */
  9.  
  10. #include "crack.h"
  11.  
  12. #define RULE_NOOP    ':'
  13. #define RULE_PREPEND    '^'
  14. #define RULE_APPEND    '$'
  15. #define RULE_REVERSE    'r'
  16. #define RULE_UPPERCASE    'u'
  17. #define RULE_LOWERCASE    'l'
  18. #define RULE_PLURALISE    'p'
  19. #define RULE_CAPITALISE    'c'
  20. #define RULE_DUPLICATE    'd'
  21. #define RULE_REFLECT    'f'
  22. #define RULE_SUBSTITUTE    's'
  23. #define RULE_MATCH    '/'
  24. #define RULE_NOT    '!'
  25. #define RULE_LT        '<'
  26. #define RULE_GT        '>'
  27. #define RULE_EXTRACT    'x'
  28.  
  29. void
  30. Trim (string)            /* remove trailing whitespace from a string */
  31.     register char *string;
  32. {
  33.     register char *ptr;
  34.  
  35.     for (ptr = string; *ptr; ptr++);
  36.     while ((--ptr >= string) && isspace (*ptr));
  37.     *(++ptr) = '\0';
  38. }
  39.  
  40. char *
  41. Clone (string, maxsize)
  42.     char *string;
  43.     int maxsize;
  44. {
  45.     register int len;
  46.     register char *retval;
  47.  
  48.     len = strlen (string);
  49.     if (maxsize && len > maxsize)
  50.     {
  51.     len = maxsize;
  52.     }
  53.     retval = (char *) malloc (len + 1);
  54.     strncpy (retval, string, len);
  55.     retval[len] = '\0';
  56.     return (retval);
  57. }
  58.  
  59. int
  60. Suffix (word, suffix)
  61.     char *word;
  62.     char *suffix;
  63. {
  64.     register int i;
  65.     register int j;
  66.  
  67.     i = strlen (word);
  68.     j = strlen (suffix);
  69.  
  70.     if (i > j)
  71.     {
  72.     return (STRCMP ((word + i - j), suffix));
  73.     } else
  74.     {
  75.     return (-1);
  76.     }
  77. }
  78.  
  79. char *
  80. Reverse (str)            /* return a pointer to a reversal */
  81.     register char *str;
  82. {
  83.     register int i;
  84.     register int j;
  85.     register char *ptr;
  86.     static char area[STRINGSIZE];
  87.  
  88.     j = i = strlen (str);
  89.     while (*str)
  90.     {
  91.     area[--i] = *str++;
  92.     }
  93.     area[j] = '\0';
  94.     return (area);
  95. }
  96.  
  97. char *
  98. Uppercase (str)            /* return a pointer to an uppercase */
  99.     register char *str;
  100. {
  101.     register char *ptr;
  102.     static char area[STRINGSIZE];
  103.  
  104.     ptr = area;
  105.     while (*str)
  106.     {
  107.     *(ptr++) = islower (*str) ? toupper (*str) : *str;
  108.     str++;
  109.     }
  110.     *ptr = '\0';
  111.  
  112.     return (area);
  113. }
  114.  
  115. char *
  116. Lowercase (str)            /* return a pointer to an lowercase */
  117.     register char *str;
  118. {
  119.     register char *ptr;
  120.     static char area[STRINGSIZE];
  121.  
  122.     ptr = area;
  123.     while (*str)
  124.     {
  125.     *(ptr++) = isupper (*str) ? tolower (*str) : *str;
  126.     str++;
  127.     }
  128.     *ptr = '\0';
  129.  
  130.     return (area);
  131. }
  132.  
  133. char *
  134. Capitalise (str)        /* return a pointer to an capitalised */
  135.     register char *str;
  136. {
  137.     register char *ptr;
  138.     static char area[STRINGSIZE];
  139.  
  140.     ptr = area;
  141.  
  142.     while (*str)
  143.     {
  144.     *(ptr++) = isupper (*str) ? tolower (*str) : *str;
  145.     str++;
  146.     }
  147.  
  148.     *ptr = '\0';
  149.  
  150.     if (islower (area[0]))
  151.     {
  152.     area[0] = toupper (area[0]);
  153.     }
  154.     return (area);
  155. }
  156.  
  157. char *
  158. Pluralise (string)        /* returns a pointer to a plural */
  159.     register char *string;
  160. {
  161.     register int length;
  162.     static char area[STRINGSIZE];
  163.  
  164.     length = strlen (string);
  165.     strcpy (area, string);
  166.  
  167.     if (!Suffix (string, "ch") ||
  168.     !Suffix (string, "ex") ||
  169.     !Suffix (string, "ix") ||
  170.     !Suffix (string, "sh") ||
  171.     !Suffix (string, "ss"))
  172.     {
  173.     /* bench -> benches */
  174.     strcat (area, "es");
  175.     } else if (length > 2 && string[length - 1] == 'y')
  176.     {
  177.     if (strchr ("aeiou", string[length - 2]))
  178.     {
  179.         /* alloy -> alloys */
  180.         strcat (area, "s");
  181.     } else
  182.     {
  183.         /* gully -> gullies */
  184.         strcpy (area + length - 1, "ies");
  185.     }
  186.     } else if (string[length - 1] == 's')
  187.     {
  188.     /* bias -> biases */
  189.     strcat (area, "es");
  190.     } else
  191.     {
  192.     /* catchall */
  193.     strcat (area, "s");
  194.     }
  195.  
  196.     return (area);
  197. }
  198.  
  199. char *
  200. Substitute (string, old, new)    /* returns pointer to a swapped about copy */
  201.     register char *string;
  202.     register char old;
  203.     register char new;
  204. {
  205.     register char *ptr;
  206.     static char area[STRINGSIZE];
  207.  
  208.     ptr = area;
  209.     while (*string)
  210.     {
  211.     *(ptr++) = *string == old ? new : *string;
  212.     string++;
  213.     }
  214.     *ptr = '\0';
  215.     return (area);
  216. }
  217.  
  218. int
  219. Char2Int (character)
  220.     char character;
  221. {
  222.     if (character >= '0' && character <= '9')
  223.     {
  224.     return (character - '0');
  225.     }
  226.     if (character >= 'a' && character <= 'z')
  227.     {
  228.     return (character - 'a' + 10);
  229.     }
  230.     if (character >= 'A' && character <= 'Z')
  231.     {
  232.     return (character - 'A' + 10);
  233.     }
  234.     return (-1);
  235. }
  236.  
  237. char *
  238. Mangle (input, control)        /* returns a pointer to a controlled Mangle */
  239.     char *input;
  240.     char *control;
  241. {
  242.     int limit;
  243.     register char *ptr;
  244.     static char area[STRINGSIZE];
  245.     char area2[STRINGSIZE];
  246.  
  247.     area[0] = '\0';
  248.     strcpy (area, input);
  249.  
  250.     for (ptr = control; *ptr; ptr++)
  251.     {
  252.     switch (*ptr)
  253.     {
  254.     case RULE_NOOP:
  255.         break;
  256.     case RULE_REVERSE:
  257.         strcpy (area, Reverse (area));
  258.         break;
  259.     case RULE_UPPERCASE:
  260.         strcpy (area, Uppercase (area));
  261.         break;
  262.     case RULE_LOWERCASE:
  263.         strcpy (area, Lowercase (area));
  264.         break;
  265.     case RULE_CAPITALISE:
  266.         strcpy (area, Capitalise (area));
  267.         break;
  268.     case RULE_PLURALISE:
  269.         strcpy (area, Pluralise (area));
  270.         break;
  271.     case RULE_REFLECT:
  272.         strcat (area, Reverse (area));
  273.         break;
  274.     case RULE_DUPLICATE:
  275.         strcpy (area2, area);
  276.         strcat (area, area2);
  277.         break;
  278.     case RULE_GT:
  279.         if (!ptr[1])
  280.         {
  281.         Log ("Mangle: '>' missing argument in '%s'\n",
  282.              control);
  283.         } else
  284.         {
  285.         limit = Char2Int (*(++ptr));
  286.         if (limit < 0)
  287.         {
  288.             Log ("Mangle: '>' weird argument in '%s'\n",
  289.              control);
  290.             return ((char *) 0);
  291.         }
  292.         if (strlen (area) <= limit)
  293.         {
  294.             return ((char *) 0);
  295.         }
  296.         }
  297.         break;
  298.     case RULE_LT:
  299.         if (!ptr[1])
  300.         {
  301.         Log ("Mangle: '<' missing argument in '%s'\n",
  302.              control);
  303.         } else
  304.         {
  305.         limit = Char2Int (*(++ptr));
  306.         if (limit < 0)
  307.         {
  308.             Log ("Mangle: '<' weird argument in '%s'\n",
  309.              control);
  310.             return ((char *) 0);
  311.         }
  312.         if (strlen (area) >= limit)
  313.         {
  314.             return ((char *) 0);
  315.         }
  316.         }
  317.         break;
  318.     case RULE_PREPEND:
  319.         if (!ptr[1])
  320.         {
  321.         Log ("Mangle: prepend missing argument in '%s'\n",
  322.              control);
  323.         } else
  324.         {
  325.         area2[0] = *(++ptr);
  326.         strcpy (area2 + 1, area);
  327.         strcpy (area, area2);
  328.         }
  329.         break;
  330.     case RULE_APPEND:
  331.         if (!ptr[1])
  332.         {
  333.         Log ("Mangle: append missing argument in '%s'\n",
  334.              control);
  335.         } else
  336.         {
  337.         register char *string;
  338.  
  339.         string = area;
  340.         while (*(string++));
  341.         string[-1] = *(++ptr);
  342.         *string = '\0';
  343.         }
  344.         break;
  345.     case RULE_SUBSTITUTE:
  346.         if (!ptr[1] || !ptr[2])
  347.         {
  348.         Log ("Mangle: substitute missing argument in '%s'\n",
  349.              control);
  350.         } else
  351.         {
  352.         strcpy (area, Substitute (area, ptr[1], ptr[2]));
  353.         ptr += 2;
  354.         }
  355.         break;
  356.     case RULE_EXTRACT:
  357.         if (!ptr[1] || !ptr[2])
  358.         {
  359.         Log ("Mangle: extract missing argument in '%s'\n",
  360.              control);
  361.         } else
  362.         {
  363.         int i;
  364.         int start;
  365.         int length;
  366.  
  367.         start = Char2Int (*(++ptr));
  368.         length = Char2Int (*(++ptr));
  369.         if (start < 0 || length < 0)
  370.         {
  371.             Log ("Mangle: extract: weird argument in '%s'\n",
  372.              control);
  373.             return ((char *) 0);
  374.         }
  375.         strcpy (area2, area);
  376.         for (i = 0; length-- && area2[start + i]; i++)
  377.         {
  378.             area[i] = area2[start + i];
  379.         }
  380.         /* cant use strncpy() - no trailing NUL */
  381.         area[i] = '\0';
  382.         }
  383.         break;
  384.     case RULE_MATCH:
  385.         if (!ptr[1])
  386.         {
  387.         Log ("Mangle: '/' missing argument in '%s'\n",
  388.              control);
  389.         } else
  390.         {
  391.         register char *string;
  392.         register char c;
  393.  
  394.         c = *(++ptr);
  395.         for (string = area; *string; string++)
  396.         {
  397.             if (*string == c)
  398.             {
  399.             break;
  400.             }
  401.         }
  402.         if (!*string)
  403.         {
  404.             return ((char *) 0);
  405.         }
  406.         }
  407.         break;
  408.     case RULE_NOT:
  409.         if (!ptr[1])
  410.         {
  411.         Log ("Mangle: '!' missing argument in '%s'\n",
  412.              control);
  413.         } else
  414.         {
  415.         register char *string;
  416.         register char c;
  417.  
  418.         c = *(++ptr);
  419.         for (string = area; *string; string++)
  420.         {
  421.             if (*string == c)
  422.             {
  423.             return ((char *) 0);
  424.             }
  425.         }
  426.         }
  427.         break;
  428.     default:
  429.         Log ("Mangle: unknown command %c in %s\n",
  430.          *ptr,
  431.          control);
  432.         break;
  433.     }
  434.     }
  435.     return (area);
  436. }
  437.