Changeset 448 for pwntcha


Ignore:
Timestamp:
Jan 10, 2005, 4:31:33 PM (16 years ago)
Author:
Sam Hocevar
Message:
  • Use font_load_* for all decoders.
Location:
pwntcha/trunk/src
Files:
1 added
11 edited
1 moved

Legend:

Unmodified
Added
Removed
  • pwntcha/trunk/src/Makefile.am

    r445 r448  
    44pwntcha_SOURCES = \
    55    main.c \
     6    filter.c \
     7    font.c \
    68    image.c \
    7     filters.c \
    89    common.h \
    910    authimage.c \
  • pwntcha/trunk/src/authimage.c

    r445 r448  
    1919#include "common.h"
    2020
    21 #define FONTNAME "font_authimage.png"
    22 static struct image *font = NULL;
    23 
    2421/* Main function */
    2522char *decode_authimage(struct image *img)
    2623{
    27     char *all = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     24    static struct font *font = NULL;
    2825    char *result;
    2926    struct image *tmp;
     
    3229    if(!font)
    3330    {
    34         char fontname[BUFSIZ];
    35         sprintf(fontname, "%s/%s", share, FONTNAME);
    36         font = image_load(fontname);
     31        font = font_load_fixed("font_authimage.png",
     32                               "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    3733        if(!font)
    38         {
    39             fprintf(stderr, "cannot load font %s\n", fontname);
    4034            exit(-1);
    41         }
    4235    }
    4336
     
    4639    memset(result, '\0', 7);
    4740
    48     /* half the captchas are inverse video; we set them back to normal */
     41    /* double the captcha size for better accuracy in the rotation */
    4942    tmp = image_dup(img);
    5043    filter_scale(tmp, 2.0);
     
    5245    filter_equalize(tmp, r * 3 / 4);
    5346    filter_smooth(tmp);
     47    filter_equalize(tmp, 220);
    5448
    5549    for(i = 0; i < 6; i++)
    5650    {
    5751        int mindiff = INT_MAX, minch = -1, ch;
    58         for(ch = 0; ch < 36; ch++)
     52        for(ch = 0; ch < font->size; ch++)
    5953        {
    6054            int diff = 0;
     
    6761                    newy = 33.0 - (x + 6 * i) * 18.0 / 34.0 + y * 42.0 / 6.0 + 0.5;
    6862                    getpixel(tmp, newx, newy, &r, &g, &b);
    69                     getpixel(font, x + 6 * ch, y, &r2, &g, &b);
    70                     r = (r < 220) ? 0 : 255;
     63                    getpixel(font->img, x + 6 * ch, y, &r2, &g, &b);
    7164                    diff += (r - r2) * (r - r2);
    7265                }
     
    7871            }
    7972        }
    80         result[i] = all[minch];
     73        result[i] = font->glyphs[minch].c;
    8174    }
    8275
  • pwntcha/trunk/src/clubic.c

    r445 r448  
    2121
    2222/* Our macros */
    23 #define FONTNAME "font_clubic.png"
    24 static struct image *font = NULL;
    2523char *result;
    2624
     
    2927{
    3028    struct image *tmp;
    31 
    32     if(!font)
    33     {
    34         char fontname[BUFSIZ];
    35         sprintf(fontname, "%s/%s", share, FONTNAME);
    36         font = image_load(fontname);
    37         if(!font)
    38         {
    39             fprintf(stderr, "cannot load font %s\n", fontname);
    40             exit(-1);
    41         }
    42     }
    4329
    4430    /* clubic captchas have 6 characters */
     
    5743static void find_glyphs(struct image *img)
    5844{
    59     char all[] = "0123456789";
    60     struct
    61     {
    62         int xmin, xmax, ymin, ymax;
    63         int count;
    64     }
    65     glyphs[10];
     45    static struct font *font = NULL;
    6646    struct image *tmp;
    6747    int x, y, i = 0;
    6848    int r, g, b;
    69     int xmin, xmax, ymin, ymax, incell = 0, count = 0, startx = 0, cur = 0;
     49    int xmin, xmax, ymin, ymax, startx = 0, cur = 0;
    7050    int distmin, distx, disty, distch;
     51
     52    if(!font)
     53    {
     54        font = font_load_variable("font_clubic.png", "0123456789");
     55        if(!font)
     56            exit(1);
     57    }
    7158
    7259    tmp = image_new(img->width, img->height);
     
    7966        }
    8067
    81     for(x = 0; x < font->width; x++)
    82     {
    83         int found = 0;
    84         for(y = 0; y < font->height; y++)
    85         {
    86             getpixel(font, x, y, &r, &g, &b);
    87             if(r < 128)
    88             {
    89                 found = 1;
    90                 count += (255 - r);
    91             }
    92         }
    93         if(found && !incell)
    94         {
    95             incell = 1;
    96             xmin = x;
    97         }
    98         else if(!found && incell)
    99         {
    100             incell = 0;
    101             xmax = x;
    102             ymin = 0;
    103             ymax = font->height;
    104             glyphs[i].xmin = xmin;
    105             glyphs[i].xmax = xmax;
    106             glyphs[i].ymin = ymin;
    107             glyphs[i].ymax = ymax;
    108             glyphs[i].count = count;
    109             count = 0;
    110             i++;
    111         }
    112     }
    113 
    114     if(i != 10)
    115     {
    116         printf("error: could not find 10 glyphs in font\n");
    117         exit(-1);
    118     }
    119 
    12068    while(cur < 6)
    12169    {
    12270        /* Try to find 1st letter */
    12371        distmin = INT_MAX;
    124         for(i = 0; i < 10; i++)
     72        for(i = 0; i < font->size; i++)
    12573        {
    12674            int localmin = INT_MAX, localx, localy;
    127             xmin = glyphs[i].xmin;
    128             ymin = glyphs[i].ymin;
    129             xmax = glyphs[i].xmax;
    130             ymax = glyphs[i].ymax;
     75            xmin = font->glyphs[i].xmin;
     76            ymin = font->glyphs[i].ymin;
     77            xmax = font->glyphs[i].xmax;
     78            ymax = font->glyphs[i].ymax;
    13179            for(y = -4; y < 4; y++)
    13280                for(x = startx; x < startx + 4; x++)
     
    13886                        {
    13987                            int r2;
    140                             getgray(font, xmin + z, ymin + t, &r);
     88                            getgray(font->img, xmin + z, ymin + t, &r);
    14189                            getgray(img, x + z, y + t, &r2);
    14290                            dist += abs(r - r2);
    14391                        }
    144                     dist = dist * 128 / glyphs[i].count;
     92                    dist = dist * 128 / font->glyphs[i].count;
    14593                    if(dist < localmin)
    14694                    {
     
    160108
    161109        /* Print min glyph */
    162         xmin = glyphs[distch].xmin;
    163         ymin = glyphs[distch].ymin;
    164         xmax = glyphs[distch].xmax;
    165         ymax = glyphs[distch].ymax;
     110        xmin = font->glyphs[distch].xmin;
     111        ymin = font->glyphs[distch].ymin;
     112        xmax = font->glyphs[distch].xmax;
     113        ymax = font->glyphs[distch].ymax;
    166114        for(y = 0; y < ymax - ymin; y++)
    167115            for(x = 0; x < xmax - xmin; x++)
    168116            {
    169                 getpixel(font, xmin + x, ymin + y, &r, &g, &b);
    170                 if(r > 128) continue;
     117                getpixel(font->img, xmin + x, ymin + y, &r, &g, &b);
     118                if(r > 128)
     119                    continue;
    171120                setpixel(tmp, distx + x, disty + y, r, g, b);
    172121            }
    173122
    174123        startx = distx + xmax - xmin;
    175         result[cur++] = all[distch];
     124        result[cur++] = font->glyphs[distch].c;
    176125    }
    177126
  • pwntcha/trunk/src/common.h

    r446 r448  
    2626        int xmin, xmax, ymin, ymax;
    2727        int count; /* Black pixel count */
     28        char c;
    2829    } *glyphs;
     30    int size;
    2931};
    3032
     
    5860int setpixel(struct image *img, int x, int y, int r, int g, int b);
    5961
     62/* font operations */
     63struct font *font_load_fixed(char *file, char *chars);
     64struct font *font_load_variable(char *file, char *chars);
     65void font_free(struct font *font);
     66
    6067/* image filters */
    6168void filter_flood_fill(struct image *img, int x, int y, int r, int g, int b);
  • pwntcha/trunk/src/linuxfr.c

    r445 r448  
    1818#include "common.h"
    1919
    20 #define FONTNAME "font_linuxfr.png"
    21 static struct image *font = NULL;
    22 
    2320/* Main function */
    2421char *decode_linuxfr(struct image *img)
    2522{
    26     char all[] = "abcdefghijklmnopqrstuvwxyz"
    27                  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    28                  "0123456789";
     23    static struct font *font = NULL;
    2924    char *result;
    3025    struct image *tmp;
    3126    int x, y, r, g, b, i, j, c;
    32     int *stats = malloc(img->height * sizeof(int));
     27    int *stats;
    3328
    3429    if(!font)
    3530    {
    36         char fontname[BUFSIZ];
    37         sprintf(fontname, "%s/%s", share, FONTNAME);
    38         font = image_load(fontname);
     31        font = font_load_fixed("font_linuxfr.png",
     32                               "abcdefghijklmnopqrstuvwxyz"
     33                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     34                               "0123456789");
    3935        if(!font)
    40         {
    41             fprintf(stderr, "cannot load font %s\n", fontname);
    4236            exit(-1);
    43         }
    4437    }
    4538
     
    4740    result = malloc(8 * sizeof(char));
    4841    memset(result, '\0', 8);
     42
     43    stats = malloc(img->height * sizeof(int));
    4944
    5045    tmp = image_dup(img);
     
    115110                int r2, g2, b2, ch;
    116111                int minerror = INT_MAX;
    117                 for(ch = 0; ch < 62; ch++)
     112                for(ch = 0; ch < font->size; ch++)
    118113                {
    119114                    int error = 0, goodch = 1;
     
    122117                        {
    123118                            getpixel(tmp, x + c * 9 + i, y + j, &r, &g, &b);
    124                             getpixel(font, ch * 9 + i, j, &r2, &g2, &b2);
     119                            getpixel(font->img, ch * 9 + i, j, &r2, &g2, &b2);
    125120                            /* Only die if font is black and image is white */
    126121                            if(r > r2)
     
    135130                    {
    136131                        minerror = error;
    137                         result[c] = all[ch];
     132                        result[c] = font->glyphs[ch].c;
    138133                        result[c+1] = '\0';
    139134                    }
  • pwntcha/trunk/src/main.c

    r444 r448  
    6464        {
    6565        case 'h': /* --help */
    66             printf("Usage: %s [OPTION]... FILE...\n", argv[0]);
     66            printf("Usage: %s [OPTION]... IMAGE...\n", argv[0]);
    6767#ifdef HAVE_GETOPT_LONG
    6868            printf("  -m, --mode <mode>  force operating mode\n");
  • pwntcha/trunk/src/phpbb.c

    r445 r448  
    1818#include "common.h"
    1919
    20 /* Our macros */
    21 #define FONTNAME "font_phpbb.png"
    22 static struct image *font = NULL;
    23 
    2420/* Main function */
    2521char *decode_phpbb(struct image *img)
    2622{
    27     char all[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
     23    static struct font *font = NULL;
    2824    char *result;
    2925    struct image *tmp1, *tmp2;
     
    3531    if(!font)
    3632    {
    37         char fontname[BUFSIZ];
    38         sprintf(fontname, "%s/%s", share, FONTNAME);
    39         font = image_load(fontname);
     33        font = font_load_fixed("font_phpbb.png",
     34                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789");
    4035        if(!font)
    41         {
    42             fprintf(stderr, "cannot load font %s\n", fontname);
    4336            exit(-1);
    44         }
    4537    }
    4638
     
    6961        /* Try to find 1st letter */
    7062        distmin = INT_MAX;
    71         for(i = 0; i < 35; i++)
     63        for(i = 0; i < font->size; i++)
    7264        {
    7365            int localmin = INT_MAX, localx, localy;
    74             xmin = i * 40;
    75             ymin = 0;
    76             xmax = i * 40 + 40;
    77             ymax = 40;
    78             for(y = 0; y < img->height - 40; y++)
     66            xmin = font->glyphs[i].xmin;
     67            ymin = font->glyphs[i].ymin;
     68            xmax = font->glyphs[i].xmax;
     69            ymax = font->glyphs[i].ymax;
     70            for(y = 0; y < img->height - (ymax - ymin); y++)
    7971            {
    8072                x = offset - 3;
     
    9183                        {
    9284                            int r2;
    93                             getgray(font, xmin + z, ymin + t, &r);
     85                            getgray(font->img, xmin + z, ymin + t, &r);
    9486                            getgray(tmp1, x + z, y + t, &r2);
    9587                            if(r > r2)
     
    116108
    117109        /* Print min glyph (debug) */
    118         xmin = distch * 40;
    119         ymin = 0;
    120         xmax = distch * 40 + 40;
    121         ymax = 40;
     110        xmin = font->glyphs[distch].xmin;
     111        ymin = font->glyphs[distch].ymin;
     112        xmax = font->glyphs[distch].xmax;
     113        ymax = font->glyphs[distch].ymax;
    122114        for(y = 0; y < ymax - ymin; y++)
    123115            for(x = 0; x < xmax - xmin; x++)
    124116            {
    125117                int r2;
    126                 getpixel(font, xmin + x, ymin + y, &r2, &g, &b);
    127                 if(r2 > 128) continue;
     118                getpixel(font->img, xmin + x, ymin + y, &r2, &g, &b);
     119                if(r2 > 128)
     120                    continue;
    128121                getpixel(tmp2, distx + x, disty + y, &r, &g, &b);
    129122                setpixel(tmp2, distx + x, disty + y, r2, g, b);
     
    131124
    132125        offset = distx + xmax - xmin;
    133         result[cur] = all[distch];
     126        result[cur] = font->glyphs[distch].c;
    134127    }
    135128
  • pwntcha/trunk/src/slashdot.c

    r446 r448  
    2121static void count_objects(struct image *img);
    2222static void rotate(struct image *img);
    23 static void cut_cells(struct image *img);
    2423static void find_glyphs(struct image *img);
    25 
    26 /* Our macros */
    27 #define FONTNAME "font_slashdot.png"
    28 
    29 struct font font;
    30 struct glyph glyphs[22];
    3124
    3225/* Global stuff */
     
    136129        }
    137130    }
    138 
    139 #if 0
    140     { CvPoint A, B;
    141       A.x = (objlist[first].xmin + objlist[first].xmax) / 2;
    142       A.y = (objlist[first].ymin + objlist[first].ymax) / 2;
    143       B.x = (objlist[last].xmin + objlist[last].xmax) / 2;
    144       B.y = (objlist[last].ymin + objlist[last].ymax) / 2;
    145       cvLine(tmp, A, B, 0, 2.0, 0);
    146     }
    147 #endif
    148131
    149132    image_swap(img, tmp);
     
    196179}
    197180
    198 static void cut_cells(struct image *img)
    199 {
    200     struct image *tmp;
    201     int x, y;
    202     int r, g, b;
    203 
    204     tmp = image_new(img->width, img->height);
    205 
    206     for(y = 0; y < img->height; y++)
    207         for(x = 0; x < img->width; x++)
    208         {
    209             getpixel(img, x, y, &r, &g, &b);
    210             setpixel(tmp, x, y, r, g, b);
    211         }
    212 
    213     for(x = 0; x < img->width; x++)
    214     {
    215         setpixel(tmp, x, 0, 255, 255, 255);
    216         setpixel(tmp, x, img->height - 1, 255, 255, 255);
    217     }
    218 
    219     for(y = 0; y < img->height; y++)
    220         for(x = 0; x < 7; x++)
    221         {
    222             setpixel(tmp, x * img->width / 7, y, 255, 255, 255);
    223             setpixel(tmp, (x + 1) * img->width / 7 - 1, y, 255, 255, 255);
    224         }
    225 
    226     image_swap(img, tmp);
    227     image_free(tmp);
    228 }
    229 
    230181static void find_glyphs(struct image *img)
    231182{
    232     char all[] = "abcdefgijkmnpqrstvwxyz";
     183    static struct font *font = NULL;
    233184    struct image *tmp;
    234185    int x, y, i = 0;
    235186    int r, g, b;
    236     int xmin, xmax, ymin, ymax, incell = 0, count = 0, startx = 0, cur = 0;
     187    int xmin, xmax, ymin, ymax, startx = 0, cur = 0;
    237188    int distmin, distx, disty, distch;
    238189
    239     if(!font.img)
    240     {
    241         char fontname[BUFSIZ];
    242         sprintf(fontname, "%s/%s", share, FONTNAME);
    243         font.img = image_load(fontname);
    244         if(!font.img)
    245         {
    246             fprintf(stderr, "cannot load font %s\n", fontname);
    247             exit(-1);
    248         }
    249         font.glyphs = glyphs;
     190    if(!font)
     191    {
     192        font = font_load_variable("font_slashdot.png", "abcdefgijkmnpqrstvwxyz");
     193        if(!font)
     194            exit(1);
    250195    }
    251196
     
    259204        }
    260205
    261     for(x = 0; x < font.img->width; x++)
    262     {
    263         int found = 0;
    264         for(y = 0; y < font.img->height; y++)
    265         {
    266             getpixel(font.img, x, y, &r, &g, &b);
    267             if(r < 128)
    268             {
    269                 found = 1;
    270                 count += (255 - r);
    271             }
    272         }
    273         if(found && !incell)
    274         {
    275             incell = 1;
    276             xmin = x;
    277         }
    278         else if(!found && incell)
    279         {
    280             incell = 0;
    281             xmax = x;
    282 #if 0
    283             ymin = font.img->height;
    284             ymax = 0;
    285             for(y = 0; y < font.img->height; y++)
    286             {
    287                 int newx;
    288                 int gotit = 0;
    289                 for(newx = xmin; newx < xmax; newx++)
    290                 {
    291                     getpixel(font.img, newx, y, &r, &g, &b);
    292                     if(r < 128)
    293                     {
    294                         gotit = 1;
    295                         break;
    296                     }
    297                 }
    298                 if(gotit)
    299                 {
    300                     if(ymin > y) ymin = y;
    301                     if(ymax <= y) ymax = y + 1;
    302                 }
    303             }
    304 #else
    305             ymin = 0;
    306             ymax = font.img->height;
    307 #endif
    308             font.glyphs[i].xmin = xmin;
    309             font.glyphs[i].xmax = xmax;
    310             font.glyphs[i].ymin = ymin;
    311             font.glyphs[i].ymax = ymax;
    312             font.glyphs[i].count = count;
    313             count = 0;
    314             i++;
    315         }
    316     }
    317 
    318     if(i != 22)
    319     {
    320         printf("error: could not find 22 glyphs in font\n");
    321         exit(-1);
    322     }
    323 
    324206    while(cur < 7)
    325207    {
    326208        /* Try to find 1st letter */
    327209        distmin = INT_MAX;
    328         for(i = 0; i < 22; i++)
     210        for(i = 0; i < font->size; i++)
    329211        {
    330212            int localmin = INT_MAX, localx, localy;
    331 //if(all[i] == 'i') continue;
    332             xmin = font.glyphs[i].xmin;
    333             ymin = font.glyphs[i].ymin;
    334             xmax = font.glyphs[i].xmax;
    335             ymax = font.glyphs[i].ymax;
    336             //printf("trying to find %c (%i×%i) - ", all[i], xmax - xmin, ymax - ymin);
     213            xmin = font->glyphs[i].xmin;
     214            ymin = font->glyphs[i].ymin;
     215            xmax = font->glyphs[i].xmax;
     216            ymax = font->glyphs[i].ymax;
    337217            for(y = -5; y < 5; y++)
    338218                for(x = startx - 5; x < startx + 5; x++)
     
    344224                        {
    345225                            int r2;
    346                             getgray(font.img, xmin + z, ymin + t, &r);
     226                            getgray(font->img, xmin + z, ymin + t, &r);
    347227                            getgray(img, x + z, y + t, &r2);
    348228                            dist += abs(r - r2);
     
    350230    //                printf("%i %i -> %i\n", x, y, dist);
    351231                    //dist /= sqrt(xmax - xmin);
    352                     dist = dist * 128 / font.glyphs[i].count;
     232                    dist = dist * 128 / font->glyphs[i].count;
    353233                    if(dist < localmin)
    354234                    {
     
    368248        }
    369249
    370         //fprintf(stderr, "%i (%i,%i)\n", distmin, distx - startx, disty);
    371         //printf("min diff: %c - %i (%i, %i)\n", all[distch], distmin, distx, disty);
    372 
    373         /* Print min glyph */
    374         xmin = font.glyphs[distch].xmin;
    375         ymin = font.glyphs[distch].ymin;
    376         xmax = font.glyphs[distch].xmax;
    377         ymax = font.glyphs[distch].ymax;
     250        /* Draw best glyph in picture (debugging purposes) */
     251        xmin = font->glyphs[distch].xmin;
     252        ymin = font->glyphs[distch].ymin;
     253        xmax = font->glyphs[distch].xmax;
     254        ymax = font->glyphs[distch].ymax;
    378255        for(y = 0; y < ymax - ymin; y++)
    379256            for(x = 0; x < xmax - xmin; x++)
    380257            {
    381                 getpixel(font.img, xmin + x, ymin + y, &r, &g, &b);
     258                getpixel(font->img, xmin + x, ymin + y, &r, &g, &b);
    382259                if(r > 128) continue;
    383260                setpixel(tmp, distx + x, disty + y, r, g, b);
     
    385262
    386263        startx = distx + xmax - xmin;
    387         result[cur++] = all[distch];
     264        result[cur++] = font->glyphs[distch].c;
    388265    }
    389266
  • pwntcha/trunk/src/test.c

    r445 r448  
    1919#include "common.h"
    2020
    21 /* Our macros */
    22 #define FONTNAME "font_phpbb.png"
    23 
    24 static void find_glyphs(struct image *img);
    25 
    26 /* Global stuff */
    27 struct { int xmin, ymin, xmax, ymax; } objlist[100];
    28 int objects, first, last;
    29 char *result;
    30 
    3121/* Main function */
    3222char *decode_test(struct image *img)
    3323{
     24    char *result;
    3425    struct image *tmp;
    35 
    36     /* Initialise local data */
    37     objects = 0;
    38     first = -1;
    39     last = -1;
    4026
    4127    /* phpBB captchas have 6 characters */
    4228    result = malloc(7 * sizeof(char));
     29    result[0] = 0;
    4330
    4431    tmp = image_dup(img);
     
    4734    filter_equalize(tmp, 130);
    4835    filter_median(tmp);
    49     find_glyphs(tmp);
    5036
    5137    image_free(tmp);
     
    5642/* The following functions are local */
    5743
    58 static void find_glyphs(struct image *img)
    59 {
    60     char all[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
    61     struct image *tmp, *font;
    62     int x, y, i = 0;
    63     int r, g, b;
    64     int xmin, xmax, ymin, ymax, cur = 0, offset = -1;
    65     int distmin, distx, disty, distch;
    66 
    67     if(!font)
    68     {
    69         char fontname[BUFSIZ];
    70         sprintf(fontname, "%s/%s", share, FONTNAME);
    71         font = image_load(fontname);
    72         if(!font)
    73         {
    74             fprintf(stderr, "cannot load font %s\n", fontname);
    75             exit(-1);
    76         }
    77     }
    78 
    79     tmp = image_new(img->width, img->height);
    80 
    81     for(x = 0; x < img->width; x++)
    82         for(y = 0; y < img->height; y++)
    83         {
    84             getpixel(img, x, y, &r, &g, &b);
    85             setpixel(tmp, x, y, 255, g, 255);
    86             if(r == 0 && offset == -1)
    87                 offset = x;
    88         }
    89 
    90     strcpy(result, "       ");
    91 
    92     while(cur < 6)
    93     {
    94         /* Try to find 1st letter */
    95         distmin = INT_MAX;
    96         for(i = 0; i < 35; i++)
    97         {
    98             int localmin = INT_MAX, localx, localy;
    99             xmin = i * 40;
    100             ymin = 0;
    101             xmax = i * 40 + 40;
    102             ymax = 40;
    103             for(y = 0; y < img->height - 40; y++)
    104             {
    105                 x = offset - 5;
    106                 if(cur == 0)
    107                     x -= 15;
    108                 if(x < 0)
    109                     x = 0;
    110                 for(; x < offset + 10; x++)
    111                 {
    112                     int z, t, dist;
    113                     dist = 0;
    114                     for(t = 0; t < ymax - ymin; t++)
    115                         for(z = 0; z < xmax - xmin; z++)
    116                         {
    117                             int r2;
    118                             getgray(font, xmin + z, ymin + t, &r);
    119                             getgray(img, x + z, y + t, &r2);
    120                             dist += abs(r - r2);
    121                         }
    122                     if(dist < localmin)
    123                     {
    124                         localmin = dist;
    125                         localx = x;
    126                         localy = y;
    127                     }
    128                 }
    129             }
    130             if(localmin < distmin)
    131             {
    132                 distmin = localmin;
    133                 distx = localx;
    134                 disty = localy;
    135                 distch = i;
    136             }
    137         }
    138 
    139         /* Print min glyph (debug) */
    140         xmin = distch * 40;
    141         ymin = 0;
    142         xmax = distch * 40 + 40;
    143         ymax = 40;
    144         for(y = 0; y < ymax - ymin; y++)
    145             for(x = 0; x < xmax - xmin; x++)
    146             {
    147                 getpixel(font, xmin + x, ymin + y, &r, &g, &b);
    148                 if(r > 128) continue;
    149                 setpixel(tmp, distx + x, disty + y, r, g, b);
    150             }
    151 
    152         offset = distx + xmax - xmin;
    153         result[cur++] = all[distch];
    154     }
    155 
    156     image_swap(img, tmp);
    157     image_free(tmp);
    158 }
    159 
  • pwntcha/trunk/src/vbulletin.c

    r445 r448  
    1818#include "common.h"
    1919
    20 #define FONTNAME "font_vbulletin.png"
    21 static struct image *font = NULL;
    22 
    2320/* Main function */
    2421char *decode_vbulletin(struct image *img)
    2522{
    26     char all[] = "2346789ABCDEFGHJKLMNPRTWXYZ";
     23    static struct font *font = NULL;
    2724    char *result;
    2825    struct image *tmp;
     
    3229    if(!font)
    3330    {
    34         char fontname[BUFSIZ];
    35         sprintf(fontname, "%s/%s", share, FONTNAME);
    36         font = image_load(fontname);
     31        font = font_load_fixed("font_vbulletin.png",
     32                               "2346789ABCDEFGHJKLMNPRTWXYZ");
    3733        if(!font)
    38         {
    39             fprintf(stderr, "cannot load font %s\n", fontname);
    4034            exit(-1);
    41         }
    4235    }
    4336
     
    115108    for(i = 0; i < 6; i++)
    116109    {
    117         struct image *new = image_dup(tmp);
    118110        int mindist = INT_MAX, min = -1;
    119         filter_crop(new, limits[i], 15, limits[i] + 11, 45);
    120         for(j = 0; j < 27; j++)
     111        for(j = 0; j < font->size; j++)
    121112        {
    122113            int dist = 0;
    123             for(y = 0; y < new->height; y++)
    124                 for(x = 0; x < new->width; x++)
     114            for(y = 0; y < 11; y++)
     115                for(x = 0; x < 30; x++)
    125116                {
    126117                    int r2, g2, b2;
    127                     getpixel(font, 12 * j + x, y, &r, &g, &b);
    128                     getpixel(new, x, y, &r2, &g2, &b2);
     118                    getpixel(font->img, 12 * j + x, y, &r, &g, &b);
     119                    getpixel(tmp, limits[i] + x, 15 + y, &r2, &g2, &b2);
    129120                    dist += (r - r2) * (r - r2);
    130121                }
     
    135126            }
    136127        }
    137         image_free(new);
    138         result[i] = all[min];
     128        result[i] = font->glyphs[min].c;
    139129    }
    140130
  • pwntcha/trunk/src/xanga.c

    r445 r448  
    2121static void fill_white_holes(struct image *img);
    2222
    23 /* Our macros */
    24 #define FACTOR 1
    25 #define FONTNAME "font_xanga.png" // use with FACTOR = 1
    26 //#define FONTNAME "font.png" // use with FACTOR = 2
    27 //#define FONTNAME "font_dilated.png" // use with FACTOR = 2
    28 static struct image *font = NULL;
    29 
    30 /* Global stuff */
    31 struct { int xmin, ymin, xmax, ymax; } objlist[100];
    32 int objects, first, last;
    33 char *result;
    34 
    3523/* Main function */
    3624char *decode_xanga(struct image *img)
    3725{
     26    static struct font *font1 = NULL, *font2 = NULL, *font3 = NULL;
    3827    struct image *tmp;
     28    char *result;
    3929
    40     /* Initialise local data */
    41     objects = 0;
    42     first = -1;
    43     last = -1;
     30    if(!font1)
     31    {
     32        font1 = font_load_variable("font_freemonobold_32_az.bmp",
     33                                   "abcdefghijklmnopqrstuvwxyz");
     34        if(!font1)
     35            exit(1);
     36    }
     37
     38    if(!font2)
     39    {
     40        font2 = font_load_variable("font_freemonobold_32_az.bmp",
     41                                   "abcdefghijklmnopqrstuvwxyz");
     42        if(!font2)
     43            exit(1);
     44    }
     45
     46    if(!font3)
     47    {
     48        font3 = font_load_variable("font_freemonobold_32_az.bmp",
     49                                   "abcdefghijklmnopqrstuvwxyz");
     50        if(!font3)
     51            exit(1);
     52    }
    4453
    4554    /* Xanga captchas have 7 characters */
     
    6978
    7079    /* Invert rotation and find glyphs */
    71     rotate(tmp);
    7280    filter_median(tmp);
    7381
     
    8795{
    8896    struct image *tmp;
    89     int x, y, i;
     97    int x, y;
    9098    int r, g, b;
    9199
Note: See TracChangeset for help on using the changeset viewer.