ebb | http :// www

So, what am I missing? Why does the "API key" works but "OAuth 2.0 token" does not?

To directly answer your question. API key only works with public data, Your not sending a valid access token as the OAuth 2 bearer token, the value you are sending is wrong.

First off an API key will only give you access to public data, so you could for example use an API key to list public videos on YouTube, or look at one of the public holiday calendars on Google Calendar. You can not use an API key to access private user data

To access private user data or any method that requires authorization you need to supply a authorization header and submit a valid bearer token.

Your issue is that you are not submitting a valid access token. it looks like you may be trying to send the client id from your project on Google cloud console. This is not an access token.

How to get an access token with CURL is a three step process the first step being requesting authorization of the user who owns the data

This is a HTTP get call and can be placed in any browser window.

you missed a semicolon After DEFAULT 0

Also you need the NEW. prefix to address the columns of the inserted row

Maybe something like this?

Your strace output makes the problem clear: connect returns an error code (between -4095 to -1), so the high bytes of EAX are 0xffffff... Later mov al, imm8¹ leaves them unmodified, resulting in EAX= invalid system call number².

If you want to make it exit cleanly even if an earlier system call returned negative, xor eax,eax / inc eax / int 0x80 at the end to do a SYS_exit. (With BL=1 or some non-zero value to exit with a non-zero status).

Or use push 0xb / pop eax to set EAX=SYS_execve for that final system call, so the shell definitely runs. (But with stdin not redirected, so that's not very good).

Or just get used to using strace as error checking, now that you understand what happens when a system call return value leaves the high bytes of EAX non-zero. You could put a ud2 at the end so it will exit with an illegal instruction instead of segfault (when execution falls into 00 00 add [eax], al bytes.)

Or if you really want, write actual error checking for the connect system call, checking for a negative EAX and using write to output an error message before exiting. That would obviously be useless in real shellcode which would run with its stdout connected to something on the victim computer, not yours. connect is the one most likely to fail, so you can still leave the other syscalls unchecked other than by strace.

Footnote 1: Remember you're using mov al, 0xb instead of mov eax, 0xb to avoid zeros in your machine code, although push 0x0100007F doesn't do that. >.< Not a problem when building as an executable, but would be a problem for injection via a strcpy or other C-string buffer overflow vulnerability.

Footnote 2: Apparently strace or the kernel is sign-extending that to 64 bits, despite the fact that the full RAX isn't accessible in 32-bit mode.

Remove the draft option, this prevents images from showing up

Not sure what version you are using, however, SELECT * FROM MY_TABLE; does not return the current content of the table, but the table's changelog stream (this holds for older versions; in newer version the query you show is not valid as the syntax was changed).

Since the transition from KSQL to ksqlDB, the query you showed would be called a push query expressed as SELECT * FROM my_table EMIT CHANGES;.

Furthermore, ksqlDB introduced pull queries that allow you to lookup the current state. However SELECT * FROM my_table; is not supported as a pull query yet (it will be added in the future). You can only do table lookups for a specific key, i.e., there must be a WHERE clause at the moment.

Check out the docs for more details: https://docs.ksqldb.io/en/latest/concepts/queries/pull/

Instead of writing this as a weird join, write it as a straightforward WHERE condition:

If you are having a problem, disabling SMAP won't solve it, it will only hide it. The fact that SMAP kills your process is good and it should stay that way, it's a security measure of the Linux kernel and it should not be disabled only to make a buggy module work.

Your error is here:

I see nothing wrong here. TLDR answer: char arrays are aligned to 1 byte, the compiler is right.

Digging a bit further. On my 64-bit machine, using GCC 7 with the -m32 option, I run and debugged the same code and I got the same results: