✨ Bem-vindo ao meu espaço! ✨ Este blog é o diário de um otaku apaixonado por animes, tecnologia de mainframe e viagens. Cada entrada é uma mistura única: relatos de viagem com fotos, filmes, links, artigos e desenhos, sempre buscando enriquecer a experiência de quem lê. Sou quase um turista profissional: adoro dormir em uma cama diferente, acordar em um lugar novo e registrar tudo com minha câmera sempre à mão. Entre uma viagem e outra, compartilho também reflexões sobre cultura otaku/animes

Mostrar mensagens com a etiqueta BellacosaMainframe. Mostrar todas as mensagens

segunda-feira, 5 de janeiro de 2026

🔥 SEU RACF ESTÁ TE PROTEGENDO… OU TE TRAINDO?

Bellacosa Mainframe em uma conversa sobre segurança mainframe

🔥 SEU RACF ESTÁ TE PROTEGENDO… OU TE TRAINDO?

🧪 LAB PRÁTICO — Do Acesso Liberado ao Controle Total no z/OS

☕ Introdução — Bem-vindo ao caos controlado

Hoje você não vai só aprender…

👉 Você vai quebrar a segurança do sistema
👉 E depois consertar como um verdadeiro admin raiz

💡 Estilo Bellacosa:

“Se você nunca viu um sistema inseguro… você ainda não entendeu segurança.”

🎯 Objetivo do LAB

Você vai:

❌ Criar um cenário inseguro (sem proteção)
🔍 Explorar a falha
🛡️ Corrigir com RACF
🔐 Validar segurança

⚠️ Cenário

Você é admin e recebe:

“Precisamos liberar rápido o dataset PROD.FINANCEIRO.*”

😈 Spoiler: isso vai dar ruim.

🧪 FASE 1 — Criando o problema (sim, de propósito)

1️⃣ Criar dataset “sensível”

//STEP1 EXEC PGM=IEFBR14
//DD1   DD DSN=PROD.FINANCEIRO.DADOS,
//      DISP=(NEW,CATLG),
//      SPACE=(TRK,(1,1)),
//      DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)

2️⃣ NÃO criar perfil RACF

👉 Sim… você vai deixar sem proteção

💡 Easter egg:

Isso acontece mais em produção do que você imagina 😅

3️⃣ Testar acesso com outro usuário

TSO LISTDS 'PROD.FINANCEIRO.DADOS'

👉 Se PROTECTALL estiver OFF:

💥 Acesso permitido

💣 Resultado

Dataset crítico → sem perfil → acesso liberado 😱

🧠 REFLEXÃO

Você acabou de:

Criar uma falha real
Simular um incidente comum

👉 E ninguém hackeou nada

🛡️ FASE 2 — Corrigindo como profissional

1️⃣ Criar perfil de dataset

RDEFINE DATASET PROD.FINANCEIRO.* UACC(NONE)

2️⃣ Permitir acesso controlado

PERMIT PROD.FINANCEIRO.* CLASS(DATASET) ID(FINUSR) ACCESS(READ)

3️⃣ Ativar proteção

SETROPTS RACLIST(DATASET) REFRESH

4️⃣ (CRÍTICO) Ativar PROTECTALL

SETROPTS PROTECTALL

💥 Agora sim:

👉 Dataset sem perfil = acesso negado

🔍 FASE 3 — Validando segurança

Teste novamente:

TSO LISTDS 'PROD.FINANCEIRO.DADOS'

👉 Resultado esperado:

ICH408I USER NOT AUTHORIZED

🔥 Agora você está protegido

⚙️ FASE 4 — Explorando comando “ALL”

LD DA('PROD.FINANCEIRO.*') ALL

👉 Vai mostrar:

Dono
Permissões
UACC
Detalhes completos

💡 Frase pra vida:

“ALL = mostra tudo. Sem ALL = você está voando no escuro.”

🔐 FASE 5 — Elevando nível com SPECIAL

Criar usuário admin

ADDUSER ADMIN1 SPECIAL

👉 Esse usuário pode:

Alterar tudo
Criar perfis
Controlar segurança

⚠️ Cuidado:

SPECIAL = poder total

⚙️ FASE 6 — Simulando programa privilegiado (APF)

👉 Imagine:

Um programa precisa acessar memória sensível

Sem APF:

❌ Falha

Com APF:

✅ Executa com privilégio

💡 Curiosidade:

Muitos ataques internos exploram programas mal autorizados no APF

🔐 FASE 7 — Criptografia (visão prática)

👉 Fluxo real:

App → ICSF → Crypto Express → dado protegido

Você não vê… mas está acontecendo.

📊 FASE 8 — Auditoria com SMF

👉 Tudo que você fez pode ser registrado:

Acesso ao dataset
Tentativas negadas
Alterações

💡 Mas só se estiver configurado 😉

🧠 Easter Eggs do LAB

PROTECTALL OFF = caos silencioso
UACC(READ) mal usado = vazamento
SPECIAL demais = bomba relógio
Sem log = sem prova

🏁 Checklist final

Você aprendeu:

✔ Criar falha real
✔ Corrigir com RACF
✔ Controlar acesso
✔ Validar segurança
✔ Entender impacto

☕ Conclusão estilo Bellacosa

Segurança no mainframe não é:

ferramenta
comando
checklist

É:

Mentalidade.

Porque no final…

👉 O sistema nunca erra
👉 Quem erra é quem configura

🔥 Desafio final

Responda:

Seu ambiente hoje está protegido…
ou só parece?

terça-feira, 4 de novembro de 2025

☕🔥 REXX: O “CALL” QUE SEPARA AMADORES DE MESTRES DO MAINFRAME 🔥☕

Bellacosa Mainframe subrotina e funções no REXX

☕🔥 REXX: O “CALL” QUE SEPARA AMADORES DE MESTRES DO MAINFRAME 🔥☕

Quando uma simples subrotina vira arquitetura corporativa no z/OS

Existe um momento curioso na vida de todo profissional de Mainframe.

No começo, o programador escreve scripts REXX pequenos:

um SAY
um PARSE
um LISTDSI
um loopzinho no TSO

Tudo parece simples…

Até o dia em que o EXEC cresce.

E cresce.

E cresce MAIS.

De repente:

o REXX virou ferramenta operacional
automatizou JES2
conversa com SDSF
consulta DB2
gera relatórios
envia alertas
dispara jobs
trata datasets
faz parsing de SYSOUT

E então nasce o monstro.

O famoso:

“REXX ESPAGUETE”

O EXEC com:

4 mil linhas
93 labels
17 GOTOs improvisados
variáveis globais brigando entre si
e um EXIT perdido que encerra tudo sem aviso.

É nesse ponto que Functions e Subroutines deixam de ser “assunto básico”.

E passam a ser:

ENGENHARIA DE SOFTWARE NO z/OS

🧠 O DIA EM QUE O REXX MUDA

A maioria aprende REXX assim:


SAY 'HELLO WORLD'

Depois:


DO I = 1 TO 10
   SAY I
END

Mas o verdadeiro salto acontece quando alguém descobre:


CALL

Parece banal.

Mas não é.

Porque o CALL introduz:

modularização
reutilização
encapsulamento
separação de responsabilidades

Ou seja:

arquitetura.

☕ A FILOSOFIA UNIX… DENTRO DO MAINFRAME

Existe uma ideia clássica no UNIX:

“Faça uma coisa… e faça bem.”

REXX absorveu isso perfeitamente.

Uma boa subrotina:

tem responsabilidade única
é reutilizável
é previsível
é segura

🔥 O ERRO QUE TODO MUNDO COMETE

O clássico:


/* REXX */

contador = 0

CALL SOMA
CALL SOMA
CALL SOMA

SAY contador

EXIT

SOMA:
contador = contador + 1
RETURN

Resultado:

O iniciante acha lindo.

O veterano começa a suar frio.

Porque:

a subrotina alterou variável global
qualquer outra rotina pode quebrar tudo
debugging vira inferno

🧨 O APOCALIPSE DAS VARIÁVEIS GLOBAIS

Em ambientes corporativos isso gera:

bugs fantasmas
comportamento imprevisível
corrupção lógica
falhas intermitentes

O tipo de erro que:

acontece só em produção
às 3h da manhã
no fechamento bancário

🛡️ PROCEDURE: O HERÓI ESQUECIDO DO REXX

Aí surge ele.

O cavaleiro do encapsulamento:


PROCEDURE

O MESMO CÓDIGO — AGORA PROFISSIONAL


/* REXX */

contador = 0

CALL SOMA
CALL SOMA
CALL SOMA

SAY contador

EXIT

SOMA:
PROCEDURE

contador = contador + 1
RETURN

Resultado:

BOOM.

Agora:

a variável ficou isolada
a rotina ficou segura
o EXEC ficou previsível

🧠 O QUE O PROCEDURE REALMENTE FAZ?

Muita gente pensa:

“Ah… ele só protege variáveis.”

Não.

Ele cria:

CONTEXTO DE EXECUÇÃO

Quase como stack frame em linguagens modernas.

Ou seja:

escopo local
isolamento
proteção de memória lógica

Isso é MUITO avançado para uma linguagem criada em 1979.

👀 EASTER EGG MAINFRAME #1

Muitos programadores COBOL estranham isso porque COBOL tradicionalmente compartilha Working-Storage de forma mais explícita.

Já o REXX:

pode ser extremamente dinâmico
extremamente perigoso
ou extremamente elegante

Tudo depende do uso do PROCEDURE.

☠️ O “EXIT” QUE MATOU PRODUÇÃO

Existe um erro lendário em REXX.

Esse aqui:


MINHAROTINA:
EXIT

O programador queria retornar.

Mas o EXIT:

encerrou o EXEC inteiro
abortou processamento
deixou JOB preso
não gerou relatório
não liberou recurso

Resultado:

operador chamou suporte
suporte chamou sysprog
sysprog chamou o programador
o programador fingiu que estava em reunião.

O CORRETO


MINHAROTINA:
RETURN

☕ EASTER EGG MAINFRAME #2

Veteranos de TSO geralmente têm trauma de:

IKJ56500I
loops infinitos
EXEC preso consumindo CPU
SDSF mostrando step “ativo eternamente”

Muitas vezes a causa era:

RETURN faltando
variável compartilhada
parsing errado

🔍 FUNCTIONS: A JOIA DO REXX

Subrotina executa ações.

Função:

calcula
transforma
retorna valor

EXEMPLO CLÁSSICO


nome = 'MAINFRAME'

tam = LENGTH(nome)

SAY tam

Resultado:

A função:

recebe argumento
processa
devolve resultado

O PODER DAS BUILT-IN FUNCTIONS

REXX é quase um canivete suíço textual.

Tem funções para:

palavras
parsing
HEX
EBCDIC
decimal
binary
formatação
datas
sistema

🔥 O MOMENTO “MATRIX” DO MAINFRAME

Quando alguém descobre:


C2X()
X2C()

o cérebro explode.

Porque agora:

dumps fazem sentido
buffers CICS fazem sentido
mensagens MQ fazem sentido
VSAM hexadecimal faz sentido

EXEMPLO


SAY C2X('A')

Resultado:

C1

E aqui está a magia.

No Windows:

“A” normalmente seria 41 hexadecimal

No Mainframe:

é C1

Porque o z/OS vive no glorioso mundo:

EBCDIC

👀 EASTER EGG MAINFRAME #3

Você sabe que alguém virou “mainframer raiz” quando ele olha:

F1F2F3

e instantaneamente pensa:

🚀 PARSE ARG — A ARTE DO REXX

Outras linguagens:


campos = texto.split()

REXX:


PARSE ARG nome sobrenome idade

Fim.

Elegante.
Natural.
Humano.

EXEMPLO PROFISSIONAL


/* REXX */

CALL PROCESSA 'VAGNER BELLACOSA MAINFRAME'

EXIT

PROCESSA:
PROCEDURE

PARSE ARG nome sobrenome area

SAY 'NOME      :' nome
SAY 'SOBRENOME:' sobrenome
SAY 'AREA      :' area

RETURN

Saída:


NOME      : VAGNER
SOBRENOME : BELLACOSA
AREA      : MAINFRAME

🔥 INTERNAL vs EXTERNAL ROUTINES

Esse conceito é GIGANTE.

INTERNAL

Dentro do mesmo EXEC.

EXTERNAL

Outro membro da PDS.

Isso permitiu nascer:

frameworks REXX
bibliotecas corporativas
automação enterprise
ferramentas operacionais gigantes

🏦 O REXX QUE NINGUÉM VÊ

Muita gente acha que Mainframe moderno vive só de:

COBOL
DB2
CICS

Mas nos bastidores…

REXX roda:

automação operacional
health checks
deployment
monitoramento
auditoria
SDSF automation
RACF tooling
DevOps z/OS

☕ EASTER EGG MAINFRAME #4

Em muitos bancos:

o sistema crítico é COBOL
mas quem “cola tudo” é REXX

O REXX virou:

a fita isolante do z/OS.

🎯 O VERDADEIRO ENSINAMENTO

Esse módulo parece ensinar:

CALL
RETURN
FUNCTION

Mas o que ele REALMENTE ensina é:

COMO ORGANIZAR PENSAMENTO

O SALTO DE MATURIDADE

O iniciante escreve:

scripts

O profissional escreve:

módulos

O especialista escreve:

frameworks reutilizáveis

O veterano escreve:

automação que parece sistema operacional.

💡 EXEMPLO FINAL — ESTILO CORPORATIVO


/* REXX */

CALL CABECALHO

usuario = USERID()
data    = DATE()
hora    = TIME()

msg = MONTA_MSG(usuario,data,hora)

CALL EXIBE msg

EXIT

/* ======================= */

CABECALHO:
PROCEDURE
SAY '================================='
SAY ' SISTEMA DE AUDITORIA MAINFRAME '
SAY '================================='
RETURN

/* ======================= */

MONTA_MSG:
PROCEDURE

PARSE ARG user,data,hora

RETURN 'USUARIO:' user ' DATA:' data ' HORA:' hora

/* ======================= */

EXIBE:
PROCEDURE

PARSE ARG texto

SAY texto

RETURN

RESULTADO


=================================
 SISTEMA DE AUDITORIA MAINFRAME
=================================

USUARIO: IBMUSER DATA: 2026-05-07 HORA: 14:32:10

☕ CONCLUSÃO

Functions e Subroutines não são “detalhes” do REXX.

São:

modularização
arquitetura
reutilização
encapsulamento
engenharia de software

E talvez essa seja a maior surpresa do Mainframe moderno:

Mesmo décadas depois…

O REXX ainda ensina conceitos que muitos sistemas distribuídos continuam tentando reaprender.

segunda-feira, 3 de novembro de 2025

🔥🧠 REXX: A ARTE DE ENSINAR O MAINFRAME A PENSAR — IF, DO, SELECT E O CÉREBRO OPERACIONAL DO z/OS 🧠🔥

Bellacosa Mainframe laços de repetição e desvio em REXX

🔥🧠 REXX: A ARTE DE ENSINAR O MAINFRAME A PENSAR — IF, DO, SELECT E O CÉREBRO OPERACIONAL DO z/OS 🧠🔥

“Enquanto muita gente achava que REXX era apenas uma linguagem de script… o mainframe já estava automatizando datacenters inteiros.”
— Bellacosa Mainframe

☕ Introdução — O Momento em Que o REXX Ganha Vida

Existe um instante mágico no aprendizado de REXX.

Até então você apenas:

executava comandos
mostrava mensagens
manipulava variáveis
fazia pequenos scripts

Mas quando aparecem:

IF
THEN
ELSE
DO
SELECT
WHILE
FOREVER

…o EXEC deixa de ser uma lista de comandos.

E passa a “pensar”.

É aqui que nasce a automação real.

É aqui que o REXX deixa de ser script.

E vira um OPERADOR DIGITAL DE MAINFRAME.

🧠 O REXX Foi Criado Para Humanos

Essa é talvez a característica mais genial da linguagem.

O REXX foi desenhado por Mike Cowlishaw com uma obsessão:

“Programas devem parecer inglês.”

E honestamente?

Ele conseguiu.

Compare isso:


if(x==1 && y!=2)

Com isso:


If x = 1 & y \= 2 Then

O segundo parece quase uma frase operacional.

Isso não foi acidente.

Foi engenharia de produtividade.

🏛️ O Contexto Histórico Que Pouca Gente Conhece

Nos anos 70 e 80:

operadores precisavam automatizar tarefas rapidamente
sysprogs precisavam integrar ferramentas
ambientes eram extremamente caros
erros humanos custavam milhões

Então nasceu uma linguagem:

✅ simples
✅ poderosa
✅ legível
✅ integrada ao host
✅ fácil para operadores

REXX não queria competir com FORTRAN.

Ele queria dominar o ambiente operacional.

E conseguiu.

⚡ O DIA EM QUE O OPERADOR DESCOBRE O IF

Existe uma transformação psicológica quando alguém aprende IF no REXX.

Antes:


Say "PROCESSANDO"

Depois:


If rc = 0 Then
   Say "JOB EXECUTADO COM SUCESSO"
Else
   Say "ABEND DETECTADO"

Agora o EXEC reage.

Analisa.

Decide.

🔥 O RC — A ENTIDADE MÍSTICA DO MAINFRAME

Se você trabalha em z/OS…

Você sabe.

RC não é apenas variável.

RC é estado emocional operacional.


If rc > 8 Then
   Say "O CAOS COMEÇOU"

😂 Easter Egg #1 — O Operador Veterano

Todo operador experiente já fez isso:


If rc = 0 Then
   Say "MILAGRE"
Else
   Say "COMO SEMPRE"

🧮 Comparações — O Cérebro Binário do EXEC

No REXX:

1 = TRUE
0 = FALSE

Simples.

Elegante.

Brutalmente eficiente.

Exemplo


Say 10 > 5

Resultado:

O EXEC literalmente responde:

“Sim. Isso é verdade.”

🧵 Comparações String — Onde o Mainframe Mostra Sua Personalidade

No mundo distribuído moderno:

espaços são ignorados
padding é irrelevante
strings são “flexíveis”

No mainframe?

HAHAHAHAHAHA.

Não.

O Trauma do Campo CHAR FIXO


campo = "IBM "

é DIFERENTE de:


"IBM"

E é aqui que nasce o operador STRICT.

⚔️ O Temido ==


Say "IBM " == "IBM"

Resultado:

Porque no mainframe:

ESPAÇOS IMPORTAM.

Muito.

🧠 Easter Egg #2 — O Programador COBOL Sentindo Dor

Quando o novato descobre isso:


Say "ABC" == "ABC   "

o espírito de milhares de layouts PIC X(80)
sussurra no vento:

“Bem-vindo ao processamento posicional…”

🚦 IF THEN ELSE — A Tomada de Decisão do z/OS

O IF no REXX é quase poético.


If user = "IBMUSER" Then
   Say "ACESSO LIBERADO"
Else
   Say "CHAMA O RACF"

🔥 O Poder do DO/END

O DO/END é o contêiner da lógica.

Ele organiza o caos.

Exemplo


If rc \= 0 Then
Do
   Say "ERRO DETECTADO"
   Say "NOTIFICANDO OPERADOR"
   Exit 8
End

☢️ Easter Egg #3 — O Exit 8 Filosófico

Existe um momento na carreira do mainframeiro em que:


Exit 8

vira linguagem universal.

🎛️ SELECT — O Menu Supremo do ISPF

O SELECT é uma obra-prima operacional.

Ele nasceu para menus.

E o ISPF praticamente respira SELECT.

Exemplo


Select

   When opcao = "1" Then
      Say "ALLOCATE"

   When opcao = "2" Then
      Say "DELETE"

   When opcao = "3" Then
      Say "LISTCAT"

   Otherwise
      Say "USUARIO INVENTANDO MODA"

End

😂 Easter Egg #4 — O Usuário Criativo

Todo sysprog conhece:


DIGITE UMA OPCAO:
_

Usuário digita:


BATATA

🔁 LOOPS — O Motor da Automação

Sem loops:

não existe monitoramento
não existe polling
não existe automação contínua
não existe scheduler inteligente

Loops são o coração operacional do REXX.

🔥 DO FOREVER — O LOOP IMORTAL


Do Forever

   "LISTCAT LEVEL(PROD)"

   If rc \= 0 Then
      Leave

End

Esse tipo de código rodou datacenters inteiros por décadas.

☕ Easter Egg #5 — O Café do Operador


Do Forever

   Say "VERIFICANDO JES2..."

   If cafe = 0 Then
      Signal DEAD

End

🧨 LEAVE — A FUGA ESTRATÉGICA


If rc > 8 Then
   Leave

O EXEC diz:

“Chega. Não vale mais continuar.”

🔄 ITERATE — O “PRÓXIMO!”


If linha = "" Then
   Iterate

Muito usado em:

leitura de datasets
parsing
filas
processamento batch

🏛️ O Mainframe Nunca Precisou de “Modernidade”

Enquanto o mundo distribuído reinventava:

automação
scripts
pipelines
workflows

O z/OS já fazia isso há décadas com:

JCL
REXX
ISPF
CLIST
SDSF
RACF automation

⚡ O REXX NÃO É “SCRIPTZINHO”

Essa é uma das maiores injustiças tecnológicas da história.

REXX controlou:

✅ bancos
✅ operadores
✅ JES2
✅ spool
✅ RACF
✅ storage
✅ ISPF
✅ automações críticas
✅ monitoramento corporativo

🧠 Exemplo Realista — Monitor Operacional


Address TSO

Do Forever

   "LISTCAT LEVEL(PROD.CRITICO)"

   If rc = 0 Then
   Do
      Say "CATALOGO OK"
   End
   Else
   Do
      Say "ALERTA!"
      Say "PROBLEMA NO CATALOGO"

      Exit 12
   End

   Call SysSleep 10

End

🔥 Easter Egg #6 — O Operador Ninja

O operador veterano olha isso:


Exit 12

e já sabe:

quem vai ligar
quem vai culpar o storage
quem vai dizer “aqui não mudou nada”

🎯 O Verdadeiro Poder do REXX

O REXX não impressiona por:

orientação a objetos
frameworks
hype
buzzwords

Ele impressiona por algo mais raro:

PRODUTIVIDADE OPERACIONAL ABSURDA.

☕ Bellacosa Mainframe Thought™

Existe uma diferença enorme entre:

“linguagem moderna”

“linguagem que mantém bancos funcionando há 40 anos.”

O REXX pertence à segunda categoria.

E honestamente?

Isso vale muito mais.

🚀 Conclusão — Quando o EXEC Aprende a Pensar

Neste momento do aprendizado:

IF dá decisão
SELECT dá organização
DO dá estrutura
LOOP dá persistência
LEAVE dá controle
ITERATE dá eficiência

E o EXEC finalmente ganha algo fundamental:

🧠 comportamento.

É aqui que nasce a automação real do mainframe.

E é aqui que muita gente percebe:

O REXX talvez seja uma das linguagens mais subestimadas da história da computação.

☕ Até o Próximo Café no Bellacosa Mainframe…

E lembre-se:


If mainframe = "VIVO" Then
   Say "O MUNDO CONTINUA FUNCIONANDO"
Else
   Say "ABEND GLOBAL"

😄🔥

Translate

segunda-feira, 5 de janeiro de 2026