☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

domingo, 9 de novembro de 2025

☕🔥 REXX PARSE: A ARTE MAINFRAME DE DESMONTAR O CAOS EM SEGUNDOS 🔥☕

 

Bellacosa Mainframe apresenta a instrução Parse no REXX

☕🔥 REXX PARSE: A ARTE MAINFRAME DE DESMONTAR O CAOS EM SEGUNDOS 🔥☕

“Enquanto muita linguagem ainda está procurando o delimitador… o REXX já terminou o trabalho.”

Existe um momento na vida de todo profissional de mainframe em que ele percebe uma verdade inevitável:

Quase tudo no z/OS é texto.

JCL é texto.
SYSOUT é texto.
JESMSGLG é texto.
LISTCAT é texto.
SMF textualizado é texto.
Parâmetros TSO são texto.
Mensagens do CICS são texto.
Relatórios batch são texto.
Até o operador nervoso digitando comando errado no console vira texto.

E então surge uma das instruções mais elegantes já criadas pela engenharia IBM:

PARSE

Uma instrução tão poderosa que parece magia negra escrita em EBCDIC.


🧠 O QUE É O PARSE?

A IBM define PARSE como:

“Resolver algo em suas partes componentes.”

Traduzindo para o dialeto Bellacosa Mainframe:

“Pegar aquele Frankenstein textual horroroso e transformar em variáveis organizadas sem sofrer.”


😱 O TRAUMA UNIVERSAL DO PARSING

Todo programador já passou por isso:

Em outras linguagens…

linha = "JOAO:30:SAOPAULO"

dados = linha.split(":")

Funciona.

Mas aí aparece:

JOAO|30|SAOPAULO

Depois:

JOAO,30,SAOPAULO

Depois:

JOAO     30SP

E de repente você está escrevendo:

  • parser,
  • regex,
  • tokenizer,
  • scanner,
  • terapia emocional.

😎 O REXX OLHA PARA ISSO E DIZ:

Parse Var linha nome ':' idade ':' cidade

Pronto.

Acabou.

Vai tomar café.


☕ O PARSE É O VERDADEIRO OPERADOR DO MAINFRAME

Porque ele aguenta:

✔ JES2
✔ IDCAMS
✔ DFSORT
✔ IEHLIST
✔ TSO
✔ ISPF
✔ RACF
✔ VTAM
✔ CICS
✔ Outputs monstruosos de utilitários IBM

Enquanto você ainda está tentando descobrir onde começa a coluna 72.


🏛️ A FILOSOFIA IBM ESCONDIDA NO PARSE

O PARSE nasceu numa época em que:

  • memória era cara,
  • CPU era preciosa,
  • programador precisava produzir rápido,
  • automação era sobrevivência.

Então a IBM criou algo brilhante:

Um parser declarativo.

Você descreve o formato.

O REXX faz o resto.


🔥 EXEMPLO 1 — O PARSE “WORD BY WORD”


Entrada

COBOL DB2 CICS JES2

Código

linha = "COBOL DB2 CICS JES2"

Parse Var linha lang1 lang2 subsystem spool

Say lang1
Say lang2
Say subsystem
Say spool

Resultado

COBOL
DB2
CICS
JES2

😏 O DETALHE GENIAL

A última variável recebe o resto.

Isso parece pequeno…

Até você perceber quantos milhões de linhas de parsing isso economizou no planeta.


💀 O TERROR DOS ARQUIVOS FIXOS

Quem nunca recebeu um arquivo assim:

000123JOAO SILVA       000045SP

…nunca sofreu de verdade no mainframe.


😎 O REXX RESPONDE COM TRANQUILIDADE

registro = "000123JOAO SILVA       000045SP"

Parse Var registro ,
1 id 7 nome 25 saldo 31 uf

Say id
Say nome
Say saldo
Say uf

RESULTADO

000123
JOAO SILVA
000045
SP

☠️ EASTER EGG MAINFRAME #1

Se você trabalhou com:

  • copybook COBOL,
  • VSAM KSDS,
  • GDG,
  • DFSORT OUTREC,

seu cérebro provavelmente já começou automaticamente a contar colunas lendo o exemplo acima.

Você não escolheu o fixed-length life.

O fixed-length life escolheu você.


🚀 PARSE COM DELIMITADOR


Entrada

CLIENTE|ATIVO|PREMIUM|BRASIL

Código

linha = "CLIENTE|ATIVO|PREMIUM|BRASIL"

Parse Var linha ,
tipo '|' ,
status '|' ,
categoria '|' ,
pais

Say tipo
Say status
Say categoria
Say pais

RESULTADO

CLIENTE
ATIVO
PREMIUM
BRASIL

🧨 ISSO ERA REVOLUCIONÁRIO

Lembre:

REXX surgiu nos anos 70.

Muitas linguagens da época ainda estavam brigando com manipulação básica de strings.

O PARSE já fazia parsing inteligente.


🤯 PARSE COM DELIMITADOR DINÂMICO

Agora vem a parte onde o REXX começa a parecer tecnologia alienígena.


EXEMPLO

delim = ';'

linha = "DB2;CICS;MQ;IMS"

Parse Var linha ,
a (delim) ,
b (delim) ,
c (delim) ,
d

RESULTADO

DB2
CICS
MQ
IMS

😳 O DELIMITADOR VEIO DE UMA VARIÁVEL

Sim.

O parser se adapta sozinho.


☕ EASTER EGG MAINFRAME #2

Todo profissional z/OS já viu isso:

IKJ56228I DATA SET NOT IN CATALOG

E imediatamente pensou:

“Hmm… isso aí daria um PARSE VAR bonito…”

Isso é sinal claro de exposição excessiva ao TSO/E.


🧠 PARSE SOURCE — O EXEC AUTOCONSCIENTE

Essa funcionalidade é absurdamente subestimada.


Código

Parse Source ,
ambiente ,
tipo ,
exec ,
ddname ,
dataset

Say ambiente
Say tipo
Say exec
Say dataset

ISSO É INSANO

Seu EXEC consegue descobrir:

✔ como foi chamado
✔ de onde veio
✔ qual dataset o contém
✔ em qual ambiente está rodando

É quase um pequeno HAL 9000 do z/OS.

Só que mais estável.


☢️ O PODER REAL DO PARSE

O PARSE não é apenas parsing.

Ele é:

  • automação,
  • observabilidade,
  • integração,
  • produtividade,
  • sobrevivência operacional.

🎯 EXEMPLO REALISTA — PARSING DE LISTCAT


Saída IDCAMS

CLUSTER -------- USER.TEST.KSDS

Código

linha = "CLUSTER -------- USER.TEST.KSDS"

Parse Var linha . '--------' dsname

Say dsname

Resultado

USER.TEST.KSDS

😎 TRÊS SEGUNDOS

Sem regex.
Sem loop.
Sem sofrimento existencial.


📼 O CLIMA DOS ANOS 80

Imagine um operador em 1987:

  • terminal verde,
  • VTAM no ar,
  • JES2 fervendo,
  • fita magnética rodando,
  • café duvidoso,
  • e um EXEC REXX automatizando tudo com PARSE.

Cyberpunk corporativo raiz.


🧨 ARMADILHA CLÁSSICA — O “UPPER”

Muita gente esquece disso:

Parse Arg nome

automaticamente faz:

PARSE UPPER ARG

RESULTADO

Entrada:

Joao

Saída:

JOAO

😅 O INICIANTE PENSA:

“Meu programa converteu sozinho!”

Sim.

O REXX gosta de surpresas.


☕ EASTER EGG MAINFRAME #3

Se você já:

  • colocou TRACE ?R,
  • esqueceu um PULL,
  • entrou em loop infinito no ISPF,
  • ou derrubou um EXEC porque um PARSE pegou coluna errada…

Parabéns.

Você foi oficialmente batizado pelo espírito ancestral do TSO/E.


🚀 O PARSE MODERNO

Hoje o PARSE ainda é extremamente relevante.

Especialmente para:

✔ automação DevOps no z/OS
✔ parsing de REST
✔ USS scripting
✔ logs JSON simplificados
✔ outputs Unix no OMVS
✔ integração híbrida
✔ automação ISPF moderna


🏆 O QUE TORNA O PARSE GENIAL?

✔ Declarativo
✔ Compacto
✔ Legível
✔ Elegante
✔ Poderoso
✔ Natural para automação
✔ Perfeito para o mundo textual IBM


☕ CONCLUSÃO

O PARSE é uma das maiores obras-primas do REXX.

Ele representa perfeitamente a filosofia clássica da IBM:

Resolver problemas reais com elegância absurda.

Enquanto muitas linguagens ainda exigem dezenas de linhas para quebrar texto…

o REXX faz isso quase como uma conversa.

E talvez seja exatamente por isso que décadas depois ele continua vivo no coração do mainframe.

Porque no fim das contas…

O z/OS pode até parecer complexo.

Mas um bom PARSE VAR sempre coloca ordem no caos.


🧩 ORIGEM DOS GOBLINS

Bellacosa Mainframe e a origem dos goblins

🧩 ORIGEM DOS GOBLINS

Os goblins surgem na mitologia europeia medieval, especialmente no folclore britânico e francês (onde o nome “gobelin” aparece no século XII).

O termo vem provavelmente do alemão kobold ou do grego kobalos, ambos significando “espírito travesso” ou “demônio enganador”.

  • Idade Média: eram espíritos domésticos que pregavam peças, escondiam objetos e assustavam viajantes.

  • Século XIX: com os contos dos Irmãos Grimm, tornaram-se pequenas criaturas grotescas, associadas a minas, cavernas e ouro.

  • Literatura moderna: Tolkien (em O Hobbit e O Senhor dos Anéis) consolidou o visual moderno — pequenos, verdes, feios e hostis.

  • Cultura japonesa: RPGs como Final Fantasy, Dragon Quest e animes (Goblin Slayer, Overlord) reforçaram a imagem do goblin como inimigo básico de qualquer aventureiro.


⚔️ CARACTERÍSTICAS GERAIS

AtributoDescrição
TamanhoPequeno (1,0–1,2 m)
AparênciaPele verde, nariz e orelhas pontudas, dentes afiados, corpo magro
AmbienteFlorestas escuras, cavernas, ruínas ou esgotos
PersonalidadeCovardes sozinhos, mas astutos e perigosos em grupo
OrganizaçãoTribos lideradas por xamãs, chefes brutais ou hobgoblins
LínguaGoblíntico ou Dialeto Orco (em D&D e Tolkien)

💪 FORÇAS E HABILIDADES

  • Numerosidade: atacam em bandos e emboscadas.

  • Velocidade e agilidade: difíceis de acertar.

  • Adaptação: usam qualquer coisa como arma, armadilha ou abrigo.

  • Cunning (astúcia): engenhosos para sobreviver — especialmente como ladrões e trapaceiros.

  • Visão no escuro: enxergam bem em cavernas e ruínas.

Em alguns universos (como Goblin Slayer), os goblins também:

  • Aprendem com os humanos;

  • Capturam e escravizam para procriação e reprodução rápida.


🩸 FRAQUEZAS

  • Luz solar: muitos têm sensibilidade à luz (sofrem penalidades ao dia).

  • Medo: facilmente aterrorizados quando o inimigo é mais forte.

  • Dependência de grupo: isolados, são presas fáceis.

  • Pele fina: baixa resistência física.


⚒️ ARMAS E EQUIPAMENTOS

  • Comuns: facas, lanças curtas, clavas, fundas, machadinhas.

  • Improvisadas: paus, ossos, pedaços de ferro ou ferramentas.

  • Armadura: couro gasto ou pedaços de metal mal ajustados.

  • Xamãs: usam magia primitiva, venenos, fogo e rituais tribais.


👁️ DETALHES VISUAIS

  • Cor da pele: verde-oliva, acinzentada ou amarelada.

  • Olhos: amarelos, laranjas ou vermelhos, brilhando no escuro.

  • Dentes e garras: sempre sujos e pontiagudos.

  • Roupa: restos de tecido, couro ou ossos — estilo “pós-batalha”.

  • Postura: curvada, saltitante, meio simiesca.

  • Cheiro: fétido, úmido, como mofo ou carniça.


🧠 CURIOSIDADES

  • O primeiro goblin de RPG aparece em Dungeons & Dragons (1974) como monstro nível 1.

  • Em The Elder Scrolls, são mais inteligentes e organizados — quase civilizados.

  • Em Final Fantasy, o “GOBLIN PUNCH” virou uma habilidade icônica.

  • Em Goblin Slayer (anime), são retratados de forma brutalmente realista — e o protagonista é obcecado em exterminá-los.

  • Alguns autores os tratam como símbolos da decadência humana: seres que imitam a civilização, mas sempre falham.


🎮 DICAS PARA RPG / GAMES

  • Uso narrativo: excelentes inimigos de introdução — fáceis de derrotar, mas perigosos em hordas.

  • Variedade:

    • Goblin arqueiro

    • Goblin ladrão

    • Goblin xamã

    • Goblin rei / boss

  • Reviravolta de história: um goblin pode ser um aliado improvável, ou o vilão que uniu as tribos.

  • Combate tático: sempre lutam com vantagem numérica, emboscadas e armadilhas.


🧬 VERSÕES NOTÁVEIS

UniversoVersão do Goblin
TolkienCriaturas das Montanhas Sombrias, parente dos orcs.
D&DRaça própria, com sociedades tribais e hierarquias.
WarcraftComerciantes e engenheiros explosivos, inteligentes e cômicos.
Goblin SlayerSeres brutais, selvagens e extremamente realistas.
Elder ScrollsTribais, mas com alguma inteligência e cultura.
Slayers / Record of Lodoss WarInimigos clássicos de baixo nível.

🎨 RESUMO ESTÉTICO

“Verde, pequeno, rápido e sujo.
Onde há escuridão, há um goblin escondido — e ele não está sozinho.”

sábado, 8 de novembro de 2025

☕🚀 REXX NO MODO TURBO: O DIA EM QUE O EXECIO VIROU UM CANHÃO DE AUTOMAÇÃO NO z/OS 🚀☕

 


Bellacosa Mainframe Lendo e gravando dataset em REXX

☕🚀 REXX NO MODO TURBO: O DIA EM QUE O EXECIO VIROU UM CANHÃO DE AUTOMAÇÃO NO z/OS 🚀☕

“Quem domina I/O em REXX deixa de escrever scripts… e começa a construir infraestrutura invisível dentro do mainframe.”

— Bellacosa Mainframe


📚 Introdução

Existe um momento específico na jornada de qualquer profissional mainframe em que tudo muda.

Até então:

  • o REXX parecia apenas uma linguagem de comandos,
  • alguns SAY,
  • uns PARSE,
  • um loop aqui,
  • um LISTDSI ali.

Mas então surge ele:

🔥 EXECIO 🔥

E junto dele:

  • datasets,
  • streams,
  • automação JES,
  • geração dinâmica de JCL,
  • pipelines batch,
  • processamento massivo,
  • e aquele sentimento perigoso de:

“Acho que agora consigo automatizar o datacenter inteiro…”

E sinceramente?

Talvez consiga mesmo.


🏛️ O VERDADEIRO PODER DO REXX

Muita gente acha que o poder do mainframe está:

  • no COBOL,
  • no CICS,
  • no DB2,
  • ou no JES2.

Mas existe um herói silencioso escondido no TSO:

⚡ O REXX ⚡

Porque ele conecta tudo.

O REXX:

  • conversa com datasets,
  • conversa com JES,
  • conversa com ISPF,
  • conversa com SDSF,
  • conversa com USS,
  • conversa com RACF,
  • conversa com operadores,
  • conversa com o sysprog,
  • e às vezes…
  • conversa até com entidades sobrenaturais chamadas ABENDs.

💾 O PRIMEIRO CONTATO COM O EXECIO

O programador iniciante vê isso:

"EXECIO * DISKR INDD (STEM REC. FINIS"

E pensa:

“Ok… parece simples.”

O sysprog experiente olha o mesmo comando e pensa:

“Esse cidadão acabou de carregar 12 milhões de linhas na memória…”


☠️ O ASTERISCO QUE DESTRÓI REGIÕES

Vamos falar sobre o famoso:

*

No EXECIO ele significa:

“Leia TUDO.”

Parece inocente.

Mas imagine executar isso em:

  • um SYSLOG gigantesco,
  • um dump textual,
  • um relatório SMF,
  • ou uma saída monstruosa de SORT.

Resultado:

IEF374I REGION BELOW 16M EXHAUSTED

Ou pior:

S878

O momento em que o operador começa a procurar seu userid no console…


🧠 O SEGREDO DOS PROFISSIONAIS: STEM VARIABLES

A IBM acertou em cheio aqui.

O uso de STEM transforma o REXX em algo elegantíssimo.


📦 Exemplo

/* LEITURA DE DATASET */

"ALLOC FI(INPUT) DA('USER.TEST.DATA') SHR"

"EXECIO * DISKR INPUT (STEM DADOS. FINIS"

SAY "TOTAL DE REGISTROS:" DADOS.0

DO I = 1 TO DADOS.0
SAY DADOS.I
END

"FREE FI(INPUT)"

🔍 O DETALHE QUE MUITA GENTE NÃO PERCEBE

DADOS.0

NÃO é um registro.

Ele contém:

  • a quantidade de linhas lidas.

Isso virou praticamente um padrão “sagrado” no universo REXX.


🧙‍♂️ O FEITICEIRO DOS DATASETS

Depois de algum tempo usando EXECIO, acontece algo curioso.

Você para de pensar em:

  • datasets

E começa a pensar em:

  • fluxos,
  • pipelines,
  • transformação de dados,
  • automação operacional.

O REXX começa a parecer um mini shell Unix dentro do z/OS.

E isso NÃO é coincidência.


🌊 STREAMS — QUANDO O REXX DESCOBRE O UNIX

A chegada das Stream Functions foi revolucionária.

Antes:

  • tudo era “registro”.

Depois:

  • tudo virou “fluxo”.

📜 Exemplo com LINEIN()

ARQ = STREAM("'USER.INPUT.DATA'","C","OPEN READ")

DO WHILE LINES(ARQ)

LINHA = LINEIN(ARQ)

SAY LINHA

END

CALL STREAM ARQ,"C","CLOSE"

Isso parece:

  • shell scripting,
  • C,
  • Python,
  • Perl,
  • Unix clássico.

A IBM basicamente trouxe a filosofia POSIX para dentro do REXX.


🤯 O DIA EM QUE O REXX VIRA DEVOPS

Agora observe isso:

JOB.1="//TESTJOB JOB (ACCT),'REXX'"
JOB.2="//STEP1 EXEC PGM=IEFBR14"
JOB.0=2

SAY SUBMIT("JOB.")

Sim.

Você acabou de:

  • gerar um JOB,
  • montar o JCL,
  • submeter para o JES2,
  • tudo dinamicamente.

☕ EASTER EGG #1 — O “SKYNET JES2”

Em algum momento da carreira todo profissional REXX cria um loop acidental assim:

DO FOREVER

SAY SUBMIT("JOB.")

END

Cinco minutos depois:

$HASP375 JOB99999 ESTIMATED LINES EXCEEDED

E nasce uma nova lenda no CPD.


⚡ EXECIO vs STREAMS

EXECIO

Modo clássico mainframe:

  • robusto
  • tradicional
  • extremamente usado

STREAMS

Modo moderno:

  • mais portátil
  • mais elegante
  • mais próximo de Unix/Linux

🏗️ O MAINFRAME É UM ECOSSISTEMA DE I/O

O z/OS inteiro gira em torno de:

  • datasets,
  • buffers,
  • canais,
  • spool,
  • VSAM,
  • logs,
  • streams,
  • records.

Quem domina I/O:

  • domina automação.

Quem domina automação:

  • domina operação.

Quem domina operação:

  • vira indispensável.

💥 O ERRO CLÁSSICO DO INICIANTE

"EXECIO * DISKR HUGEFILE (STEM BIG."

Quando:

  • HUGEFILE tem 48 milhões de registros.

O storage começa a evaporar.

O SDSF fica lento.

O operador abre incidente.

O sysprog começa a investigar.

E você:

  • apenas queria “dar uma olhadinha no arquivo”.

🧠 O PADRÃO PROFISSIONAL REAL

Os veteranos fazem assim:

DO FOREVER

"EXECIO 100 DISKR INPUT (STEM REC."

IF RC <> 0 THEN LEAVE

DO I = 1 TO REC.0

SAY REC.I

END

END

Isso:

  • escala melhor,
  • consome menos memória,
  • evita tragédias operacionais.

☕ EASTER EGG #2 — O “FINIS ESQUECIDO”

Poucas coisas assustam mais um sysprog do que descobrir:

"EXECIO * DISKR INPUT (STEM REC."

Sem:

FINIS

O dataset continua aberto…

E às vezes:

  • lockado,
  • preso,
  • pendurado,
  • amaldiçoado pelo espírito ancestral do ENQ.

👻 O FANTASMA DO DATASET EM USO

Todo mundo já viu:

DATA SET IN USE

E passou 40 minutos procurando:

  • TSO preso,
  • ISPF órfão,
  • batch zombie,
  • ou um REXX abandonado.

🚀 BPXWDYN — O SUPER SAIYAJIN DO ALLOC

Depois vem ele:

BPXWDYN

O allocation moderno do z/OS.


📜 Exemplo

CALL BPXWDYN "ALLOC FI(INPUT) DA(USER.TEST) SHR"

Muito mais poderoso que:

  • ALLOC tradicional.

Mais elegante.
Mais flexível.
Mais “Unixificado”.


🌌 O REXX COMO LINGUAGEM UNIVERSAL DO z/OS

Poucas linguagens conseguem:

  • operar JES,
  • ler spool,
  • manipular datasets,
  • chamar ISPF,
  • usar USS,
  • conversar com RACF,
  • abrir sockets,
  • automatizar operações.

O REXX consegue.

E faz isso há décadas.


☕ EASTER EGG #3 — O SYSADM OCULTO

Existe uma regra não escrita no mainframe:

“Se um ambiente está funcionando perfeitamente há 20 anos… provavelmente existe um REXX misterioso sustentando tudo.”

Ninguém sabe:

  • quem escreveu,
  • quando escreveu,
  • ou como funciona.

Mas todos têm medo de apagar.


🧬 O DNA DO MAINFRAME MODERNO

Hoje:

  • DevOps,
  • automação,
  • pipelines,
  • integração contínua,
  • observabilidade,
  • self-healing systems…

Tudo isso já existia conceitualmente no z/OS há muito tempo.

E o REXX participou disso silenciosamente.


🎯 Conclusão

Aprender:

  • EXECIO,
  • STREAMS,
  • LINEIN,
  • LINEOUT,
  • BPXWDYN,
  • SUBMIT,

não é apenas aprender I/O.

É aprender:

como o mainframe respira.

Porque no fundo:

  • o z/OS é movimento de dados,
  • fluxo de informação,
  • buffers,
  • registros,
  • streams,
  • spool,
  • mensagens,
  • eventos.

E o REXX é uma das linguagens que melhor conversa com esse universo.


☕ Bellacosa Mainframe Final Advice

Se você realmente quiser evoluir em REXX:

Pare de fazer apenas:

  • scripts.

Comece a construir:

  • automações,
  • frameworks,
  • pipelines,
  • ferramentas operacionais,
  • inteligência operacional.

Porque é aí que o REXX deixa de ser linguagem…

E vira:

infraestrutura invisível do mainframe.

🕶️ DIABOLIK NO MAINFRAME — Red Team e a Arte de Atacar as Certezas

 

Bellacosa Mainframe e diabolik entra no redt eam

☕ Um Café no Bellacosa Mainframe

🕶️ DIABOLIK NO MAINFRAME — Red Team e a Arte de Atacar as Certezas

O melhor Red Team não pergunta apenas como invadir o mainframe. Pergunta quais certezas precisam deixar de ser verdade para que o próprio ambiente abra caminho para o incidente.



Imagine a cena.

São 03:17.

O IBM Z continua funcionando.

As LPARs estão ativas. CICS responde. Db2 está disponível. JES2 continua processando sua fila. RACF permanece de pé. O SIEM está recebendo eventos. Há redundância de rede. Existe um segundo caminho. Os operadores estão na sala.

No dashboard, quase tudo continua verde.

Então alguém pergunta:

— Estamos seguros?

E Diabolik sorri.

Porque essa é a pergunta errada.

A pergunta interessante é:

Quais coisas precisam deixar de funcionar simultaneamente para transformar uma arquitetura aparentemente segura em uma arquitetura vulnerável?

Bem-vindo ao Red Team.

E, principalmente, bem-vindo ao Red Team visto sob a tutela de Diabolik, o criminoso fictício que não ficou famoso simplesmente pela força bruta.

Diabolik observa.

Planeja.

Estuda pessoas.

Entende rotinas.

Explora confiança.

Procura exceções.

E espera.

Esse último verbo é importantíssimo.

Porque um atacante sofisticado não precisa encontrar um sistema permanentemente vulnerável.

Ele pode esperar pelo momento em que o sistema temporariamente se torna vulnerável.

No mainframe isso muda completamente nossa maneira de pensar segurança.



🕶️ CAPÍTULO 1 — Diabolik não começa pelo RACF

Imagine que contratamos uma equipe para realizar um exercício autorizado de Red Team em uma grande organização que utiliza IBM Z.

A abordagem superficial começaria perguntando:

Qual versão do z/OS?

Existe RACF?

Existe MFA?

Como está a rede?

Quais aplicações estão expostas?

Existem APIs?

Existe USS?

Existe Zowe?

Tudo isso importa.

Mas Diabolik provavelmente começaria antes.

Ele colocaria sobre a mesa uma folha em branco e escreveria:

ASSET

O que realmente estamos protegendo?

Talvez:

CORE BANKING
CARD AUTHORIZATION
PIX
CUSTOMER DATA
PAYROLL
SECURITIES
INSURANCE
CLEARING
SETTLEMENT

Agora outra pergunta:

THREAT ACTORS

De quem estamos protegendo esses ativos?

Depois:

TRUST

Em quem o funcionamento desses sistemas confia?

Finalmente:

ASSUMPTIONS

Quais condições acreditamos que sempre serão verdadeiras?

É aqui que a investigação começa a ficar interessante.

Porque podemos descobrir que a organização possui milhões investidos em tecnologia, mas toda aquela arquitetura depende de algumas premissas extremamente humanas.

Por exemplo:

O operador seguirá o procedimento.

A conta privilegiada será usada corretamente.

O segundo link estará disponível.

O backup será recuperável.

O certificado será renovado.

O alerta será investigado.

A mudança será registrada.

O fornecedor continuará confiável.

A conta de serviço permanecerá protegida.

Alguém interromperá o processo se algo der errado.

Diabolik circula essa última frase.

"Alguém interromperá."

Será?



🎭 CAPÍTULO 2 — Red Team não é apenas invasão

Existe uma caricatura bastante comum de Red Team.

Alguém de moletom preto diante de seis monitores digitando furiosamente:

ACCESS GRANTED

Pronto.

Invadimos.

Mas Red Team maduro é muito mais interessante.

O exercício autorizado tenta colocar determinadas premissas defensivas sob pressão.

Pergunta:

Se um adversário real estivesse estudando nossa organização, quais caminhos poderiam levá-lo aos ativos importantes?

Isso envolve tecnologia, mas também:

  • identidade;

  • processos;

  • segregação de funções;

  • configuração;

  • monitoramento;

  • fornecedores;

  • procedimentos;

  • comportamento;

  • contingência;

  • comunicação;

  • resposta a incidentes;

  • governança.

Nosso estudo anterior chegou exatamente a esse ponto: o Red Team deixa de olhar apenas para o controle isolado e começa a investigar a arquitetura de confiança.

No mainframe isso é extraordinariamente importante.

Porque IBM Z raramente vive sozinho.

Temos algo parecido com:

USER
  ↓
DEVICE
  ↓
NETWORK
  ↓
IDENTITY
  ↓
APPLICATION
  ↓
CICS / IMS
  ↓
COBOL
  ↓
DB2 / VSAM

Mas existem dezenas de arestas laterais:

APIs
MQ
FTP/SFTP
z/OS Connect
USS
Zowe
Schedulers
DevOps
CI/CD
Cloud
Distributed Systems
Service Accounts
Vendors
Automation

Segurança é um grafo.

E cada aresta representa alguma forma de confiança.



🕸️ CAPÍTULO 3 — Diabolik desenha o grafo

Pegue um programa COBOL aparentemente inocente:

BILLING01

Talvez ele leia:

CUSTOMER
ACCOUNT
TRANSACTION
PRODUCT

e atualize:

INVOICE

O iniciante poderia pensar:

PROGRAM → DATABASE

Diabolik desenharia:

                    USER
                      │
                      ▼
                   RACF ID
                      │
               ┌──────┴──────┐
               ▼             ▼
             CICS           BATCH
               │             │
               ▼             ▼
            BILLING01      JCL/JES
               │             │
          ┌────┴────┐        │
          ▼         ▼        ▼
        DB2        VSAM    DATASET
          │
          ▼
       CUSTOMER

Depois continuaria:

CI/CD ──────► LOADLIB
                ▲
                │
DEVELOPER ──────┘

SERVICE ACCOUNT ──► AUTOMATION

API ──► z/OS Connect ──► CICS

MQ ──► APPLICATION

Agora temos algo muito mais interessante.

Porque a pergunta deixou de ser:

O Db2 está protegido?

Passou a ser:

Quantos caminhos diferentes podem produzir uma alteração relevante no estado desse negócio?

Esse é pensamento de Red Team.



🔐 CAPÍTULO 4 — RACF não protege contra todas as formas de confiança

RACF é extraordinariamente importante.

Mas existe uma armadilha conceitual:

RACF = SEGURANÇA

Não.

RACF é uma parte da arquitetura de segurança.

Imagine:

USER01
READ   DATASET.A

USER01
UPDATE DATASET.B

USER01
EXECUTE TRANSACTION.C

USER01
SUBMIT JOB.D

Cada permissão individualmente pode ter justificativa.

Auditor pergunta:

READ A?
OK.

UPDATE B?
OK.

CICS C?
OK.

JOB D?
OK.

Quatro verdes.

Diabolik pergunta:

READ A
+
UPDATE B
+
TRANSACTION C
+
JOB D
=
?

Essa é uma pergunta completamente diferente.

Não estamos mais analisando permissões isoladas.

Estamos analisando capacidade acumulada.

O usuário talvez não possua uma permissão perigosa.

Pode possuir uma combinação perigosa de permissões legítimas.

Essa diferença é fundamental.



🧩 CAPÍTULO 5 — Compartmentalization

Aqui aparece um princípio antigo de segurança e inteligência: compartimentalização.

Compare:

USUÁRIO A
├── desenvolvimento
├── aprovação
├── implantação
├── produção
├── auditoria
└── rollback

com:

DEV      → desenvolvimento
APPROVER → aprovação
OPS      → implantação
SEC      → segurança
AUDIT    → auditoria

Por que dividir?

Porque comprometimento possui blast radius.

Se uma identidade conhece, controla ou executa tudo, comprometer aquela identidade potencialmente compromete tudo.

O mesmo raciocínio vale para pessoas.

Vale para contas técnicas.

Vale para pipelines.

Vale para fornecedores.

Vale para APIs.

Vale para certificados.

Vale até para informações aparentemente banais.

Não precisamos transformar cada funcionário em suspeito.

O objetivo é exatamente o contrário: construir um sistema no qual a confiança em uma única pessoa não seja suficiente para destruir o modelo inteiro.


👤 CAPÍTULO 6 — Insider Threat não significa vilão

Quando falamos em insider threat, muita gente imediatamente imagina:

FUNCIONÁRIO TRAIDOR

Esse é apenas um cenário.

Insider risk pode envolver:

malícia
erro
negligência
coerção
engenharia social
credencial comprometida
procedimento inadequado
excesso de privilégio
informação excessiva
automação mal configurada

Imagine um analista autorizado.

Ele não deseja prejudicar ninguém.

Mas possui:

PRODUCTION ACCESS

Recebe uma solicitação aparentemente normal.

Executa determinada atividade.

O problema talvez não seja:

BAD EMPLOYEE

Pode ser:

BAD PROCESS

Um sistema resiliente deve presumir que humanos eventualmente erram.

Por isso temos segregação.

Aprovação.

Logging.

Monitoring.

Least privilege.

Dual control.

Change management.

Não porque todo mundo seja criminoso.

Porque confiança absoluta é um controle de segurança péssimo.


🎬 CAPÍTULO 7 — A fotografia virou filme

Aqui chegamos ao nosso Risk Scoring.

A segurança tradicional frequentemente produz fotografias:

USER01 = LOW RISK

Diabolik pergunta:

Quando?

08:00?

11:30?

03:17?

O contexto muda.

Por isso deveríamos pensar:

RISK(t)

Risco como função do tempo.

Imagine:

08:00

USER01
LOCATION = NORMAL
DEVICE   = MANAGED
ACTION   = NORMAL
RISK     = 20

Agora:

03:17

USER01
UNUSUAL CONTEXT
PRIVILEGED ACTION
CHANGE WINDOW
MULTIPLE FAILURES
RISK = ?

O usuário continua sendo USER01.

Mas o contexto deixou de ser o mesmo.

É exatamente por isso que comportamento importa.

Não perguntamos apenas:

WHO ARE YOU?

Perguntamos:

IS WHAT YOU ARE DOING
CONSISTENT WITH
WHAT WE EXPECT?

🧮 CAPÍTULO 8 — Risk Score não é sentença

É importante não transformar Risk Scoring em numerologia.

Podemos imaginar pedagogicamente:

BASELINE.................... 20
privileged operation........ +15
unusual context............. +10
change detected............. +10
control degraded............ +15
unexpected dependency....... +10
-------------------------------
RISK........................ 80

Esses números são ilustrativos.

O princípio importa mais que o peso.

Cada evento altera contexto.

Portanto:

EVENT
   ↓
CONTEXT
   ↓
RISK RECALCULATION
   ↓
DECISION

Isso permite decisões graduais:

ALLOW

CHALLENGE

REQUIRE APPROVAL

LIMIT

ESCALATE

STOP

Diabolik detestaria principalmente a última.


🚨 CAPÍTULO 9 — CHANGE é um evento de segurança

Mainframe conhece Change Management muito bem.

Mudou:

JCL
COBOL
PARMLIB
PROCLIB
LOADLIB
RACF
DB2
CICS
IMS
MQ
NETWORK
CERTIFICATE

Registramos.

Aprovamos.

Testamos.

Ou deveríamos.

Mas Red Team acrescenta outra pergunta:

O que mais mudou como consequência dessa mudança?

Imagine:

PRIMARY LINK DOWN

Temos backup.

Ótimo.

Então:

BACKUP LINK DEGRADED

Ainda funciona.

Então:

MONITORING DELAY

Ainda funciona.

Então:

SECURITY ALERT

Provavelmente falso positivo.

Então alguém diz:

BYPASS

Separadamente:

LINK FAILURE       = manageable
BACKUP DEGRADED    = manageable
MONITORING DELAY   = manageable
ALERT              = manageable
BYPASS             = manageable

Juntos:

FAILURE
+
DEGRADATION
+
BLINDNESS
+
ALERT
+
BYPASS
=
CRITICAL STATE

Esse é o filme que a fotografia não mostra.


🧀 CAPÍTULO 10 — O queijo suíço chegou à LPAR

Existe uma metáfora maravilhosa para isso: o Swiss Cheese Model.

Imagine várias barreiras.

IDENTITY
████████○████

NETWORK
███○█████████

RACF
█████████○███

APPLICATION
█████○███████

MONITORING
██○██████████

Cada camada possui imperfeições.

Normalmente os buracos não se alinham.

Uma camada compensa a outra.

Mas existe uma condição perigosa:

○
○
○
○
○
│
▼
INCIDENT

Diabolik não precisa destruir todas as fatias.

Precisa encontrar o momento em que os buracos se alinham.

Essa é uma maneira extraordinária de ensinar defesa em profundidade.


💥 CAPÍTULO 11 — Ataque a redundância

Temos:

LPAR A
LPAR B

Excelente.

Mas:

LPAR A ─┐
        ├── DEPENDENCY X
LPAR B ─┘

Temos realmente redundância?

Talvez tenhamos dois componentes com single point of failure compartilhado.

Isso aparece em inúmeras arquiteturas:

2 SERVERS
1 NETWORK

2 APPLICATIONS
1 DATABASE

2 LINKS
1 PROVIDER

2 ADMINS
1 PRIVILEGED ACCOUNT

2 SYSTEMS
1 CERTIFICATE

Diabolik procura exatamente isso.

Não necessariamente:

WHAT IS MISSING?

Mas:

WHAT DO ALL THESE THINGS
SECRETLY DEPEND ON?

Essa pergunta deveria estar pendurada em toda War Room.


🧠 CAPÍTULO 12 — Normalization of Deviance

Agora aparece um inimigo extremamente humano.

Primeiro:

"Hoje vamos fazer uma exceção."

Nada acontece.

Depois:

"Fizemos isso semana passada."

Nada acontece.

Mais tarde:

"Fazemos sempre assim."

Finalmente:

"Nem sei por que existe essa regra."

Parabéns.

A exceção virou processo.

Isso é normalização do desvio.

E existe um erro lógico perigosíssimo associado:

FIZEMOS 100 VEZES
E NADA ACONTECEU

Portanto:

É SEGURO

Não.

A conclusão correta é:

100 EXECUÇÕES
SEM INCIDENTE

Somente isso.

Ausência histórica de desastre não prova ausência de risco.


🛑 CAPÍTULO 13 — Quem pode apertar STOP?

Essa talvez seja uma das perguntas mais importantes de toda esta história.

Imagine:

NORMAL OPERATION
       ↓
     CHANGE
       ↓
  RISK INCREASE
       ↓
       ???

Quem pode dizer:

STOP

?

Existe autoridade?

Existe procedimento?

Existe pressão para continuar?

O operador consegue interromper uma operação crítica?

O gerente aceitará?

O negócio pressionará?

Existe escalation path?

Esse componente organizacional pode ser mais importante que determinado produto de cybersecurity.

O fluxo saudável seria:

CHANGE DETECTED
       ↓
     STOP
       ↓
    ASSESS
       ↓
  RECALCULATE
       ↓
   ┌───┴───┐
   ▼       ▼
CONTINUE  ABORT

Não:

CHANGE
 ↓
"VAI ASSIM MESMO"

⏳ CAPÍTULO 14 — Temporal Attack Surface

Aqui está um conceito delicioso para nossa investigação.

Superfície de ataque normalmente é apresentada como:

PORTS
APIs
SERVICES
USERS
DEVICES
NETWORKS

Mas existe também uma dimensão temporal.

Imagine:

00:00 ───────────────────────── 23:59
                 │
             03:17
                 │
          ATTACK WINDOW

Talvez durante alguns minutos aconteçam simultaneamente:

CHANGE WINDOW
+
REDUCED STAFF
+
DEGRADED CONTROL
+
PRIVILEGED ACTIVITY
+
MONITORING NOISE

Às 09:00 alguém audita:

RACF.......... OK
NETWORK....... OK
CICS.......... OK
DB2........... OK
MONITORING.... OK

Tudo verde.

Mas isso é uma fotografia das 09:00.

O incidente ocorreu às 03:17.

Precisamos reconstruir:

02:55
03:01
03:07
03:12
03:16
03:17
03:18
03:25

Agora temos um filme.


🕵️ CAPÍTULO 15 — Diabolik procura combinações

Uma auditoria convencional pode produzir:

CONTROL A = PASS
CONTROL B = PASS
CONTROL C = PASS
CONTROL D = PASS

Diabolik pergunta:

A + B + C + D = ?

Melhor ainda:

A DEGRADED
+
B BYPASSED
+
C DELAYED
+
D MISINTERPRETED
=
?

Esse é o coração do exercício.

Não testar apenas controles.

Testar interações entre controles.


🔬 CAPÍTULO 16 — Como transformar isso em exercício defensivo

Uma organização pode estruturar um exercício autorizado sem sair tentando "hackear tudo".

Primeiro:

1. IDENTIFY ASSETS

Quais serviços não podem parar?

Depois:

2. MAP TRUST

Quem e o que possui acesso?

Depois:

3. MAP DEPENDENCIES

De que cada componente depende?

Depois:

4. IDENTIFY ASSUMPTIONS

O que estamos assumindo que nunca falhará?

Depois:

5. CREATE SAFE SCENARIOS

Por exemplo:

E se o link primário desaparecer?

E se uma conta privilegiada precisar ser bloqueada?

E se o SIEM ficar temporariamente indisponível?

E se o operador principal não estiver presente?

E se uma mudança emergencial acontecer?

E se um fornecedor estiver indisponível?

E se o segundo caminho compartilhar a mesma dependência?

Depois:

6. OBSERVE RESPONSE

Finalmente:

7. IMPROVE CONTROLS

Esse é Red Team gerando engenharia.

Não espetáculo.


🖥️ CAPÍTULO 17 — O COBOL também entra na investigação

Nosso programador COBOL iniciante talvez esteja pensando:

— Mas eu apenas programo.

Não existe "apenas programo" em sistemas críticos.

Imagine:

IF AUTHORIZED
    PERFORM UPDATE-ACCOUNT
END-IF.

A pergunta tradicional é:

AUTHORIZED funciona?

Red Team pergunta:

Quem determina AUTHORIZED?

De onde vem esse estado?

Ele pode ficar obsoleto?

Existe contexto?

Existe logging?

Existe override?

Quem aprova?

O que acontece em erro?

FAIL OPEN ou FAIL CLOSED?

Uma pequena condição COBOL pode representar uma enorme decisão de negócio.

Por isso segurança não termina no RACF.

Ela atravessa aplicação, dados e processo.


🧪 CAPÍTULO 18 — O teste mais perigoso é o pressuposto

Faça uma reunião.

Pergunte:

O que nunca pode acontecer aqui?

Alguém responderá:

"Os dois links nunca cairão juntos."

Anote.

Outro:

"Ninguém compartilha essa conta."

Anote.

Outro:

"Produção nunca recebe alteração sem aprovação."

Anote.

Outro:

"Se o monitoramento parar, perceberemos."

Anote.

Outro:

"Nosso fornecedor cuida disso."

Circule duas vezes.

Essas frases são excelentes candidatas para exercícios defensivos.

Red Team é, em grande parte, uma máquina de transformar:

EU ACHO

em:

NÓS TESTAMOS

🎩 CAPÍTULO 19 — O Easter Egg das 03:17

Nos artigos Bellacosa Mainframe, 03:17 aparece quando alguma coisa resolveu acontecer justamente na hora em que ninguém queria.

Aqui ele ganha significado especial.

Às 03:17 não precisamos imaginar um invasor cinematográfico digitando furiosamente.

Podemos imaginar:

03:17:00 CONTROL A DEGRADED

03:17:03 DEPENDENCY B UNAVAILABLE

03:17:07 AUTOMATION RETRY

03:17:12 OPERATOR OVERRIDE

03:17:18 SECURITY EVENT

03:17:21 ALERT DELAYED

Diabolik não criou necessariamente nenhuma dessas condições.

Ele apenas adoraria descobrir que elas podem coexistir.

E esse é o Easter Egg:

O momento mais perigoso de uma arquitetura talvez não seja quando alguma coisa quebra. É quando várias coisas continuam funcionando mal o suficiente para ninguém decidir parar.


🕶️ CAPÍTULO 20 — A verdadeira lição de Diabolik

Diabolik não deveria nos ensinar a ser criminosos.

Como metáfora de Red Team, deveria ensinar-nos a pensar como adversários para construir sistemas melhores.

Ele não pergunta apenas:

COMO QUEBRO O RACF?

Pergunta:

POR QUE PRECISARIA QUEBRÁ-LO?

Não:

COMO DERRUBO A REDUNDÂNCIA?

Mas:

ELA É REALMENTE INDEPENDENTE?

Não:

COMO ENGANAR O OPERADOR?

Mas:

O PROCESSO DEPENDE DEMAIS DE UMA PESSOA?

Não:

COMO DESATIVAR O ALERTA?

Mas:

O QUE ACONTECE QUANDO O ALERTA
APARECE NO PIOR MOMENTO POSSÍVEL?

Essa mudança de mentalidade é enorme.


☕ EPÍLOGO — O mainframe que confiava demais

Às 03:17 daquela noite imaginária, nosso mainframe não estava sem segurança.

Esse é justamente o problema.

Ele possuía:

RACF
SIEM
MFA
NETWORK SECURITY
SEGREGATION
CHANGE MANAGEMENT
BACKUP
REDUNDANCY
MONITORING
PROCEDURES

Tudo existia.

Mas segurança não é a soma dos produtos instalados.

Segurança é o comportamento da arquitetura quando o mundo deixa de colaborar com nossas premissas.

É por isso que Red Team importa.

Blue Team pergunta:

Estamos detectando ataques?

Purple Team aproxima ataque e defesa.

Auditoria pergunta:

Os controles estão implementados?

Operações pergunta:

O serviço está disponível?

Risk Management pergunta:

Qual é nossa exposição?

E nosso Diabolik imaginário entra silenciosamente na War Room, olha para aquele enorme painel verde e faz outra pergunta:

"Qual dessas coisas verdes precisa ficar amarela para fazer as outras perderem valor?"

Silêncio.

Essa é a pergunta.

Porque o adversário sofisticado não precisa derrotar todas as nossas defesas.

Não precisa derrubar o IBM Z.

Não precisa destruir RACF.

Não precisa comprometer cada aplicação.

Não precisa vencer cada operador.

Pode precisar apenas encontrar:

FAILURE
+
CHANGE
+
EXCEPTION
+
TRUST
+
PREDICTABILITY
+
TIMING

e esperar que essas condições se encontrem.

Por isso eu resumiria toda a filosofia do Bellacosa Red Team Mainframe numa única equação:

SECURITY ≠ CONTROLS

Segurança real é:

SECURITY =
CONTROLS
+
CONTEXT
+
RESILIENCE
+
OBSERVABILITY
+
SEGREGATION
+
GOVERNANCE
+
ABILITY TO STOP

E o Risk Scoring completa:

RISK = RISK(t)

O risco de ontem não é necessariamente o risco de agora.

O usuário continua sendo o mesmo.

O programa COBOL continua sendo o mesmo.

A LPAR continua sendo a mesma.

O RACF continua sendo o mesmo.

Mas alguma coisa mudou.

E CHANGE pode transformar uma arquitetura.

Essa talvez seja a maior lição de Diabolik para quem trabalha com IBM Mainframe:

Não procure somente a vulnerabilidade. Procure a combinação de condições que transforma controles individualmente fortes em uma arquitetura coletivamente fraca.

Porque uma fortaleza não precisa perder todas as muralhas para ser penetrável.

Basta existir uma noite em que a ponte esteja abaixada, o guarda esteja olhando para outro lado, a contingência tenha sido improvisada e alguém diga:

"Está funcionando.

Pode continuar."

E, em algum lugar da War Room, o relógio muda silenciosamente para:

03:17

Diabolik sorri.

O Red Team anota.

E o Blue Team, na manhã seguinte, transforma aquela descoberta em uma arquitetura melhor.

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...