Join Us and become a Member for a Verified Badge to access private areas with the latest PS4 PKGs.
PS4 Jailbreaking       Thread starter PSXHAX       Start date Feb 6, 2016 at 4:40 PM       101      
Status
Not open for further replies.
Following rumors of a PS4 Jailbreak USB Whistle & CFW, today juampa21 of ConsoleCrunch.com reports news of an upcoming PS4 Cobra USB Game Emulator (DRM Device) with details below.

To quote: "Hello dear crunchers its juampa21 and today I bring you some exciting news about the PS4 scene!

So according to the Cobra Team they are planning to announce and release the COBRA USB PS4 game emulator which will make PS4 users be able to enable homebrew applications and may allow play non-copyrighted downloaded games on their PS4 system!

Here i provide you some images about the post!"

That said, if anyone has an account there and can mirror the pictures elsewhere we'll add them to this article as well. ;)

:alert: PSA: For those considering such a DRM device, keep in mind the notorious history of ringleaders Max Louarn (aka MAXiMiLiEN of Paradox) and Gary Wayne Bowser (aka GaryOPA) of the Cobra Team... over the years they've profited from countless scene developers work wrapping it in their own digital rights management packages including the original PSJailbreak, TrueBlue dongle, etc instead of keeping the scene FREE and OPEN SOURCE.

Spoiler

Thanks @sEKTOR for the news tip! :)

Updated from Wololo, to quote: ''So is this a mutating rumor here? The author of the originating “news” does not point to any source for his information, and has been a member of the forum where the rumor was initially posted, for less than 2 month.

I contacted people close to the Cobra team who have told me Team Cobra is not currently working on the PS4. The only ongoing known project of Team Cobra is the Cobra Blackfin for PS Vita, which has been significantly delayed for unknown reasons (we’re following up on that). In other words, this new rumor is most likely the h3ck34 fake mutating into something slightly different."

Download: BF_manual.rar / Blackfin-1.0.rar / ADI Blackfin GNU Toolchain / Blackfin SDK / EVAL-ADICUP360
I add from myself: it seems all is not as it should be. although it was clear that the cobra has been psvita (by sEKTOR).
PS4_Cobra_USB.jpg
 

Comments

ppl here people there are blind if you believe* in it. if they think all cobra is capable of is dongle drm.
laugh at someone like garyOPA but do your research first
these guys are no joke and my m8 can attest to it.
if you know your way around emulators. good luck. cus they are no bloody joke
 
that was the point lel was just showing that just the old one that played isos and ps2 games back in the day,because some people were showing the logo and saying "was a ps4 thing on their site" lol
Ok thanks for the info wasn't aware of that part.
I'm well aware of the cobra team and what they can do I've also torn apart all of there work it's very simple
 
Code:
#define post_install (msg) printf("installing pkg",(msg))
#define install_flag(FLAG)(1<<(FLAG))

  if (flag)

  return -1;


} while (0)
 
Code:
#include "common.h"

static int is_file(char *file);

void read_pair(char *line, char *k, char *v)
{
    char *s = "=";
    char *whole;
    whole = strsep(&line, s);
    strcpy(k, whole);
    if (line != NULL)
    {
        strcpy(v, line);
    }
    else
    {
        strcpy(v, "");
    }
    return;
}

int read_line(FILE *fd, char *line)
{
    int i = 0;
    char c = 0;
    while((c != NEWLINE) && (i < MAXPATHLEN))
    {
        c = getc(fd);
        if (feof(fd))
        {
            return(-1);
        }
        *line++ = c;
        ++i;
    }
    if (*line == NEWLINE)
    {
    }
    *--line = (char)NULL;
    return(0);
}

int get_home(char *line)
{
    int i;
    for(i = 0; environ[i] != NULL; i++)
    {
        if(!strncmp(environ[i], "HOME=", 5))
        {
            strcpy(line, environ[i]);
            return 1;
        }
    }
    return 0;
}

char * trim(char *s)
{
    int len = strlen(s);
    int i = len;
    while (i > 0)
    {
        if (s[i-1] != ' ')
        {
            break;
        }
        i--;
    }
    while(len > 0)
    {
        if (*s != ' ')
        {
            break;
        }
        *s++;
        len--;
    }
    s[i] = '\0';
    return s;
}

char * dupstr(char *s)
{
    char *r;
    r = malloc(strlen(s) + 1);
    strcpy(r, s);
    return(r);
}

char * stripwhite(char *string)
{
    register char *s, *t;
    for (s = string; whitespace(*s); s++);

     if (*s == 0)
    {
        return(s);
    }
    t = s + strlen(s) - 1;
    while(t > s && whitespace(*t))
    {
        t--;
    }
    *++t = '\0';
    return s;
}

int arg_device_check(char *arg)
{
    if ((strstr(arg, ":/")) != NULL )
    {
        return 1;
    }
    else if ((strstr(arg, "host0:")) != NULL )
    {
        return 1;
    }
    else if ((strstr(arg, ":")) != NULL )
    {
        return 1;
    }
    return 0;
}

void arg_prepend_host(char *new, char *old)
{
    char *pstr_ptr;
    if ((pstr_ptr = strstr(old, ":/")) != NULL )
    {
        (void)strcpy(new, old);
    }
    else if ((pstr_ptr = strstr(old, "host0:")) != NULL )
    {
        pstr_ptr = strstr(pstr_ptr, ":");
        ++pstr_ptr;
        (void)strcpy(new, "host0:");
       (void)strcat(new, pstr_ptr);
    }
    else if ((pstr_ptr = strstr(old, ":")) != NULL )
    {
        (void)strcpy(new, old);
    }
    else
    {
        (void)strcpy(new, "host0:");
        (void)strcat(new, old);
    }
}

int fix_cmd_arg(char *argv, const char *cmd, int *argvlen)
{
    char arg[MAXPATHLEN];
    int argc;
    int ai, pi, ac;
    ai = 0;
    pi = 0;
    ac = 0;
    argc = 0;
    while (cmd[pi])
    {
        while ((cmd[pi] != '\0') && (cmd[pi] != ' '))
        {
            pi++;
        }
        memcpy(arg, &cmd[ai], pi-ai);
        arg[pi-ai] = '\0';
        if ( is_file(arg) != NULL )
        {
            if ( !arg_device_check(arg) )
            {
               
                memcpy(&argv[ac], "host0:", 6);
                memcpy(&argv[ac+6], arg, strlen(arg));
                ac += strlen(arg)+6;
            }
            else
            {               
                memcpy(&argv[ac], arg, strlen(arg));
                ac += strlen(arg);
            }
        }
        else
        {               
            memcpy(&argv[ac], arg, strlen(arg));
            ac += strlen(arg);
        }
        argv[ac] = '\0';
        ac++;
        ai = pi;
        ai++;
   
        argc++;
        while ((cmd[pi]) && (cmd[pi] == ' '))
        {
            pi++;
        }
    }
    *argvlen = ac;
    return argc;
}

int read_file(char *file, unsigned char *data, unsigned int size)
{
    FILE *fd = fopen(file, "rb");
    if (fread(data, size, 1, fd) != size)
    {
        return -1;
    }
    return size;
}

int size_file(char *file)
{
    struct stat finfo;
    if (stat(file, &finfo) != 0)
    {
        return 0;
    }
    return (finfo.st_size);
}

static int is_file(char *file)
{
    struct stat finfo;
    if (stat(file, &finfo) != 0)
    {
        return 0;
    }
    return (S_ISREG(finfo.st_mode));
}

void split_filename(char *device, char *dir, char *filename, const char *arg)
{
    char *ptr;
    memset(device, 0, MAXPATHLEN);
    memset(dir, 0, MAXPATHLEN);
    memset(filename, 0, MAXPATHLEN);
    // check for device name
    if ((ptr = strstr(arg, ":")) != NULL )
    {
        if ( (ptr - arg) > MAXPATHLEN )
        {
            device[0] = NULL;
        }
        else
        {
            strncpy(device, arg, ptr-arg+1);
            device[ptr-arg+1] = NULL;
        }
        ptr++;
    }
    else
    {
        device[0] = NULL;
        ptr = arg;
    }
    // check for dir part

    // check for filename part
    strncpy(filename, ptr, MAXPATHLEN);
    return;
}

int get_register_index(char *str, int size)
{
    int i;
    for(i = 0; i < DUMP_REG_MAX; i++)
    {
        if(!strncmp(str, DUMP_REG_SYM[i], size) )
        {
            break;
        }
    }
    return i;
}

int build_argv(char *argv[], char *arg)
{
    int i, ai;
    char *aptr = arg;

    if ((arg == NULL) || (strlen(arg) == 0))
    {
        argv[0] = NULL;
        return 0;
    }

    for(i = 0; i < MAX_ARGV; i++)
    {
        ai = 0;
        while ((aptr[ai] != '\0') && (aptr[ai] != ' '))
        {
            ai++;
        }

        argv[i] = malloc(ai);
        strncpy(argv[i], aptr, ai);
        argv[i][ai] = 0;
        aptr = aptr + ai;

        while (aptr[0] == ' ')
        {
            aptr++;
        }
        if(aptr[0] == '\0')
        {
            break;
        }
    }
    return i+1;
}

void free_argv(char *argv[], int argc)
{
    int i;
    for(i = 0; i < argc; i++) {
        free(argv[i]);
    }
    return;
}
no good way to 3.15 is easier to find the key to the encoding.
 
Status
Not open for further replies.
Back
Top